diff --git a/.github/workflows/precompile.yml b/.github/workflows/precompile.yml index f1b90d0..b1ef088 100644 --- a/.github/workflows/precompile.yml +++ b/.github/workflows/precompile.yml @@ -10,58 +10,57 @@ permissions: jobs: precompile: - runs-on: ${{ matrix.os }} + runs-on: ${{ matrix.job.os }} env: MIX_ENV: "prod" - OTP_VERSION: ${{ matrix.otp }} - ELIXIR_VERSION: ${{ matrix.elixir }} - ImageOS: ${{ matrix.os }} - name: Precompile for Elixir ${{ matrix.elixir }}, OTP ${{ matrix.otp }}, OS ${{ matrix.os }} + name: Precompile for Elixir ${{ matrix.job.elixir }}, OTP ${{ matrix.job.otp }}, OS ${{ matrix.job.os }} strategy: fail-fast: false matrix: - os: ["ubuntu18", "ubuntu20", "windows-2019", "macos-11"] - elixir: ["1.14"] - otp: ["25", "23"] - exclude: - - os: "windows-2019" - otp: "23" + job: + - { os: "ubuntu-20.04", otp: "23", elixir: "1.14" } + - { os: "macos-11", otp: "24.3.4.16", elixir: "1.14.3"} + - { os: "windows-2019", otp: "25", elixir: "1.14"} steps: - uses: actions/checkout@v3 - uses: erlef/setup-beam@v1 - if: matrix.os != 'macos-11' + if: matrix.job.os != 'macos-11' with: - otp-version: ${{ matrix.otp }} - elixir-version: ${{ matrix.elixir }} - + otp-version: ${{ matrix.job.otp }} + elixir-version: ${{ matrix.job.elixir }} - name: Install erlang and elixir - if: matrix.os == 'macos-11' + if: matrix.job.os == 'macos-11' run: | - if [ "${{ matrix.otp }}" = "23" ]; then - brew install "erlang@${{ matrix.otp }}" - brew link --overwrite "erlang@${{ matrix.otp }}" + export ROOT_DIR=$(pwd) + + mkdir -p ./cache/otp + curl -fSL https://github.com/cocoa-xu/otp-build/releases/download/v${{ matrix.job.otp }}/otp-x86_64-apple-darwin.tar.gz -o ./cache/otp/otp-v${{ matrix.job.otp }}-x86_64-apple-darwin.tar.gz + cd ./cache/otp + tar -xzf otp-v${{ matrix.job.otp }}-x86_64-apple-darwin.tar.gz + cd ${ROOT_DIR} + + export PATH=$(pwd)/cache/otp/usr/local/bin:$(pwd)/./cache/elixir/elixir-${{ matrix.job.elixir }}/bin:${PATH} + export ERL_ROOTDIR=$(pwd)/cache/otp/usr/local/lib/erlang + + mkdir -p ./cache/elixir + curl -fSL https://github.com/elixir-lang/elixir/archive/refs/tags/v${{ matrix.job.elixir }}.tar.gz -o ./cache/elixir/elixir-${{ matrix.job.elixir }}.tar.gz + cd ./cache/elixir + tar -xzf elixir-${{ matrix.job.elixir }}.tar.gz + cd elixir-${{ matrix.job.elixir }} + make compile + make -j$(sysctl -n hw.ncpu) install - export ELIXIR_VER=1.14.3 - mkdir -p "${HOME}/.elixir/v${ELIXIR_VER}" - cd "${HOME}/.elixir/v${ELIXIR_VER}" - wget "https://github.com/elixir-lang/elixir/releases/download/v${ELIXIR_VER}/elixir-otp-${{ matrix.otp }}.zip" -O "elixir-${ELIXIR_VER}.zip" - unzip "elixir-${ELIXIR_VER}.zip" - rm -f "elixir-${ELIXIR_VER}.zip" - export PATH="${HOME}/.elixir/v${ELIXIR_VER}/bin:${PATH}" - else - brew install erlang elixir - fi mix local.hex --force mix local.rebar --force - uses: ilammy/msvc-dev-cmd@v1 - if: matrix.os == 'windows-2019' + if: matrix.job.os == 'windows-2019' with: arch: x64 - name: Install system dependencies - if: matrix.os == 'ubuntu20' + if: matrix.job.os == 'ubuntu-20.04' run: | sudo apt-get update sudo apt-get install -y build-essential automake autoconf pkg-config bc m4 unzip zip wget \ @@ -74,7 +73,7 @@ jobs: gcc-s390x-linux-gnu g++-s390x-linux-gnu - name: Get musl cross-compilers - if: matrix.os == 'ubuntu20' + if: matrix.job.os == 'ubuntu-20.04' run: | for musl_arch in x86_64 aarch64 riscv64 do @@ -85,10 +84,10 @@ jobs: - name: Create precompiled library shell: bash run: | - if [ "${{ matrix.os }}" = "macos-11" ]; then - export ELIXIR_VER=1.14.3 - export PATH="${HOME}/.elixir/v${ELIXIR_VER}/bin:${PATH}" - elif [ "${{ matrix.os }}" = "ubuntu20" ]; then + if [ "${{ matrix.job.os }}" = "macos-11" ]; then + export PATH=$(pwd)/cache/otp/usr/local/bin:$(pwd)/./cache/elixir/elixir-${{ matrix.job.elixir }}/bin:${PATH} + export ERL_ROOTDIR=$(pwd)/cache/otp/usr/local/lib/erlang + elif [ "${{ matrix.job.os }}" = "ubuntu-20.04" ]; then for musl_arch in x86_64 aarch64 riscv64 do export PATH="$(pwd)/${musl_arch}-linux-musl-cross/bin:${PATH}" diff --git a/c_src/duckdb/duckdb.cpp b/c_src/duckdb/duckdb.cpp index 042ff1f..9e6d70c 100644 --- a/c_src/duckdb/duckdb.cpp +++ b/c_src/duckdb/duckdb.cpp @@ -1290,6 +1290,8 @@ class ViewCatalogEntry : public StandardEntry { vector types; //! The returned names of the view vector names; + //! The comments on the columns of the view: can be empty if there are no comments + vector column_comments; public: unique_ptr GetInfo() const override; @@ -1354,7 +1356,7 @@ class DefaultSchemaGenerator : public DefaultGenerator { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.hpp +// duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp // // //===----------------------------------------------------------------------===// @@ -1451,7 +1453,7 @@ class ObjectCache { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/options/state_machine_options.hpp +// duckdb/execution/operator/csv_scanner/state_machine_options.hpp // // //===----------------------------------------------------------------------===// @@ -1461,7 +1463,7 @@ class ObjectCache { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/options/csv_option.hpp +// duckdb/execution/operator/csv_scanner/csv_option.hpp // // //===----------------------------------------------------------------------===// @@ -1824,7 +1826,7 @@ struct CSVStateMachineOptions { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/sniffer/quote_rules.hpp +// duckdb/execution/operator/csv_scanner/quote_rules.hpp // // //===----------------------------------------------------------------------===// @@ -1846,7 +1848,7 @@ enum class QuoteRule : uint8_t { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/state_machine/csv_state.hpp +// duckdb/execution/operator/csv_scanner/csv_state.hpp // // //===----------------------------------------------------------------------===// @@ -1889,6 +1891,11 @@ class StateMachine { //! For the Quoted State bool skip_quoted[256]; + uint64_t delimiter = 0; + uint64_t new_line = 0; + uint64_t carriage_return = 0; + uint64_t quote = 0; + uint64_t escape = 0; const CSVState *operator[](idx_t i) const { return state_machine[i]; } @@ -1924,7 +1931,6 @@ class CSVStateMachineCache : public ObjectCacheEntry { //! It first caches it, then returns it. const StateMachine &Get(const CSVStateMachineOptions &state_machine_options); - static const string STATE_KEY; static string ObjectType() { return "CSV_STATE_MACHINE_CACHE"; } @@ -2159,6 +2165,7 @@ class FunctionExpression : public ParsedExpression { + // NOTE: this file is generated by scripts/generate_extensions_function.py. Check out the check-load-install-extensions // job in .github/workflows/LinuxRelease.yml on how to use it @@ -2169,208 +2176,242 @@ struct ExtensionEntry { char extension[48]; }; -static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {{"->>", "json"}, - {"add_parquet_key", "parquet"}, - {"array_to_json", "json"}, - {"create_fts_index", "fts"}, - {"current_localtime", "icu"}, - {"current_localtimestamp", "icu"}, - {"dbgen", "tpch"}, - {"drop_fts_index", "fts"}, - {"dsdgen", "tpcds"}, - {"excel_text", "excel"}, - {"from_json", "json"}, - {"from_json_strict", "json"}, - {"from_substrait", "substrait"}, - {"from_substrait_json", "substrait"}, - {"fuzz_all_functions", "sqlsmith"}, - {"fuzzyduck", "sqlsmith"}, - {"get_substrait", "substrait"}, - {"get_substrait_json", "substrait"}, - {"host", "inet"}, - {"iceberg_metadata", "iceberg"}, - {"iceberg_scan", "iceberg"}, - {"iceberg_snapshots", "iceberg"}, - {"icu_calendar_names", "icu"}, - {"icu_sort_key", "icu"}, - {"json", "json"}, - {"json_array", "json"}, - {"json_array_length", "json"}, - {"json_contains", "json"}, - {"json_deserialize_sql", "json"}, - {"json_execute_serialized_sql", "json"}, - {"json_extract", "json"}, - {"json_extract_path", "json"}, - {"json_extract_path_text", "json"}, - {"json_extract_string", "json"}, - {"json_group_array", "json"}, - {"json_group_object", "json"}, - {"json_group_structure", "json"}, - {"json_keys", "json"}, - {"json_merge_patch", "json"}, - {"json_object", "json"}, - {"json_quote", "json"}, - {"json_serialize_plan", "json"}, - {"json_serialize_sql", "json"}, - {"json_structure", "json"}, - {"json_transform", "json"}, - {"json_transform_strict", "json"}, - {"json_type", "json"}, - {"json_valid", "json"}, - {"load_aws_credentials", "aws"}, - {"make_timestamptz", "icu"}, - {"parquet_file_metadata", "parquet"}, - {"parquet_kv_metadata", "parquet"}, - {"parquet_metadata", "parquet"}, - {"parquet_scan", "parquet"}, - {"parquet_schema", "parquet"}, - {"pg_clear_cache", "postgres_scanner"}, - {"pg_timezone_names", "icu"}, - {"postgres_attach", "postgres_scanner"}, - {"postgres_query", "postgres_scanner"}, - {"postgres_scan", "postgres_scanner"}, - {"postgres_scan_pushdown", "postgres_scanner"}, - {"read_json", "json"}, - {"read_json_auto", "json"}, - {"read_json_objects", "json"}, - {"read_json_objects_auto", "json"}, - {"read_ndjson", "json"}, - {"read_ndjson_auto", "json"}, - {"read_ndjson_objects", "json"}, - {"read_parquet", "parquet"}, - {"reduce_sql_statement", "sqlsmith"}, - {"row_to_json", "json"}, - {"scan_arrow_ipc", "arrow"}, - {"sql_auto_complete", "autocomplete"}, - {"sqlite_attach", "sqlite_scanner"}, - {"sqlite_scan", "sqlite_scanner"}, - {"sqlsmith", "sqlsmith"}, - {"shapefile_meta", "spatial"}, - {"st_area", "spatial"}, - {"st_area_spheroid", "spatial"}, - {"st_asgeojson", "spatial"}, - {"st_ashexwkb", "spatial"}, - {"st_astext", "spatial"}, - {"st_aswkb", "spatial"}, - {"st_boundary", "spatial"}, - {"st_buffer", "spatial"}, - {"st_centroid", "spatial"}, - {"st_collect", "spatial"}, - {"st_collectionextract", "spatial"}, - {"st_contains", "spatial"}, - {"st_containsproperly", "spatial"}, - {"st_convexhull", "spatial"}, - {"st_coveredby", "spatial"}, - {"st_covers", "spatial"}, - {"st_crosses", "spatial"}, - {"st_difference", "spatial"}, - {"st_dimension", "spatial"}, - {"st_disjoint", "spatial"}, - {"st_distance", "spatial"}, - {"st_distance_spheroid", "spatial"}, - {"st_drivers", "spatial"}, - {"st_dump", "spatial"}, - {"st_dwithin", "spatial"}, - {"st_dwithin_spheroid", "spatial"}, - {"st_endpoint", "spatial"}, - {"st_envelope", "spatial"}, - {"st_envelope_agg", "spatial"}, - {"st_equals", "spatial"}, - {"st_extent", "spatial"}, - {"st_exteriorring", "spatial"}, - {"st_flipcoordinates", "spatial"}, - {"st_geometrytype", "spatial"}, - {"st_geomfromgeojson", "spatial"}, - {"st_geomfromhexewkb", "spatial"}, - {"st_geomfromhexwkb", "spatial"}, - {"st_geomfromtext", "spatial"}, - {"st_geomfromwkb", "spatial"}, - {"st_intersection", "spatial"}, - {"st_intersection_agg", "spatial"}, - {"st_intersects", "spatial"}, - {"st_intersects_extent", "spatial"}, - {"st_isclosed", "spatial"}, - {"st_isempty", "spatial"}, - {"st_isring", "spatial"}, - {"st_issimple", "spatial"}, - {"st_isvalid", "spatial"}, - {"st_length", "spatial"}, - {"st_length_spheroid", "spatial"}, - {"st_linemerge", "spatial"}, - {"st_linestring2dfromwkb", "spatial"}, - {"st_list_proj_crs", "spatial"}, - {"st_makeenvelope", "spatial"}, - {"st_makeline", "spatial"}, - {"st_makepolygon", "spatial"}, - {"st_makevalid", "spatial"}, - {"st_ngeometries", "spatial"}, - {"st_ninteriorrings", "spatial"}, - {"st_normalize", "spatial"}, - {"st_npoints", "spatial"}, - {"st_numgeometries", "spatial"}, - {"st_numinteriorrings", "spatial"}, - {"st_numpoints", "spatial"}, - {"st_overlaps", "spatial"}, - {"st_perimeter", "spatial"}, - {"st_perimeter_spheroid", "spatial"}, - {"st_point", "spatial"}, - {"st_point2d", "spatial"}, - {"st_point2dfromwkb", "spatial"}, - {"st_point3d", "spatial"}, - {"st_point4d", "spatial"}, - {"st_pointn", "spatial"}, - {"st_pointonsurface", "spatial"}, - {"st_polygon2dfromwkb", "spatial"}, - {"st_quadkey", "spatial"}, - {"st_reverse", "spatial"}, - {"st_read", "spatial"}, - {"st_read_meta", "spatial"}, - {"st_readosm", "spatial"}, - {"st_readshp", "spatial"}, - {"st_reduceprecision", "spatial"}, - {"st_removerepeatedpoints", "spatial"}, - {"st_simplify", "spatial"}, - {"st_simplifypreservetopology", "spatial"}, - {"st_startpoint", "spatial"}, - {"st_touches", "spatial"}, - {"st_transform", "spatial"}, - {"st_union", "spatial"}, - {"st_union_agg", "spatial"}, - {"st_within", "spatial"}, - {"st_x", "spatial"}, - {"st_xmax", "spatial"}, - {"st_xmin", "spatial"}, - {"st_y", "spatial"}, - {"st_ymax", "spatial"}, - {"st_ymin", "spatial"}, - {"stem", "fts"}, - {"text", "excel"}, - {"to_arrow_ipc", "arrow"}, - {"to_json", "json"}, - {"tpcds", "tpcds"}, - {"tpcds_answers", "tpcds"}, - {"tpcds_queries", "tpcds"}, - {"tpch", "tpch"}, - {"tpch_answers", "tpch"}, - {"tpch_queries", "tpch"}}; // END_OF_EXTENSION_FUNCTIONS +struct ExtensionFunctionEntry { + char name[48]; + char extension[48]; + CatalogType type; +}; + +static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { + {"->>", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"add_parquet_key", "parquet", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"array_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"create_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"current_localtime", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_localtimestamp", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"dbgen", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, + {"drop_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"dsdgen", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, + {"excel_text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"family", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_json_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_substrait", "substrait", CatalogType::TABLE_FUNCTION_ENTRY}, + {"from_substrait_json", "substrait", CatalogType::TABLE_FUNCTION_ENTRY}, + {"fuzz_all_functions", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"fuzzyduck", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"get_substrait", "substrait", CatalogType::TABLE_FUNCTION_ENTRY}, + {"get_substrait_json", "substrait", CatalogType::TABLE_FUNCTION_ENTRY}, + {"host", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"iceberg_metadata", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"iceberg_scan", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"iceberg_snapshots", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"icu_calendar_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY}, + {"icu_sort_key", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json", "json", CatalogType::MACRO_ENTRY}, + {"json_array", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_array_length", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_contains", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_deserialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_execute_serialized_sql", "json", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"json_execute_serialized_sql", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"json_extract", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_extract_path", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_extract_path_text", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_extract_string", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_group_array", "json", CatalogType::MACRO_ENTRY}, + {"json_group_object", "json", CatalogType::MACRO_ENTRY}, + {"json_group_structure", "json", CatalogType::MACRO_ENTRY}, + {"json_keys", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_merge_patch", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_object", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_quote", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_serialize_plan", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_serialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_structure", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_transform", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_transform_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_type", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_valid", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"load_aws_credentials", "aws", CatalogType::TABLE_FUNCTION_ENTRY}, + {"make_timestamptz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"parquet_file_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_kv_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_scan", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_schema", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"pg_clear_cache", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"pg_timezone_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_attach", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_query", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_scan", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_scan_pushdown", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json_objects_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_ndjson", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_ndjson_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_ndjson_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_parquet", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"reduce_sql_statement", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"row_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"scan_arrow_ipc", "arrow", CatalogType::TABLE_FUNCTION_ENTRY}, + {"shapefile_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sql_auto_complete", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqlite_attach", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqlite_scan", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqlsmith", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_area", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_area_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_asgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ashexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_astext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_aswkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_boundary", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_buffer", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_centroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_collect", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_collectionextract", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_contains", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_containsproperly", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_convexhull", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_coveredby", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_covers", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_crosses", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_difference", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_dimension", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_disjoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_distance", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_distance_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_drivers", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_dump", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_dwithin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_dwithin_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_endpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_envelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_envelope_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_equals", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_exteriorring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_flipcoordinates", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force3dm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force3dz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geometrytype", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromhexewkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromhexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromtext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_intersection", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_intersection_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_intersects", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_intersects_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isclosed", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isempty", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_issimple", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isvalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_length", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_length_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_linemerge", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_linestring2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_list_proj_crs", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_m", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makeenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makeline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makepolygon", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makevalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_mmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_mmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ngeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ninteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_normalize", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_npoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_numgeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_numinteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_numpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_overlaps", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_perimeter", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_perimeter_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point3d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_pointn", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_pointonsurface", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_polygon2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_quadkey", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_read", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_read_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_readosm", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_readshp", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_reduceprecision", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_removerepeatedpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_reverse", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_simplify", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_simplifypreservetopology", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_startpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_touches", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_transform", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_union", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_union_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_within", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_x", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_xmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_xmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_y", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ymax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ymin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_z", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_zmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_zmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"stem", "fts", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_arrow_ipc", "arrow", CatalogType::TABLE_FUNCTION_ENTRY}, + {"to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"tpcds", "tpcds", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"tpcds_answers", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, + {"tpcds_queries", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, + {"tpch", "tpch", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"tpch_answers", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, + {"tpch_queries", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, +}; // END_OF_EXTENSION_FUNCTIONS static constexpr ExtensionEntry EXTENSION_SETTINGS[] = { + {"azure_account_name", "azure"}, + {"azure_context_caching", "azure"}, + {"azure_credential_chain", "azure"}, + {"azure_endpoint", "azure"}, + {"azure_http_proxy", "azure"}, + {"azure_http_stats", "azure"}, + {"azure_proxy_password", "azure"}, + {"azure_proxy_user_name", "azure"}, + {"azure_read_buffer_size", "azure"}, + {"azure_read_transfer_chunk_size", "azure"}, + {"azure_read_transfer_concurrency", "azure"}, {"azure_storage_connection_string", "azure"}, + {"azure_transport_option_type", "azure"}, {"binary_as_string", "parquet"}, + {"ca_cert_file", "httpfs"}, {"calendar", "icu"}, + {"enable_server_cert_verification", "httpfs"}, {"force_download", "httpfs"}, + {"http_keep_alive", "httpfs"}, {"http_retries", "httpfs"}, {"http_retry_backoff", "httpfs"}, {"http_retry_wait_ms", "httpfs"}, {"http_timeout", "httpfs"}, - {"http_keep_alive", "httpfs"}, - {"pg_debug_show_queries", "postgres_scanner"}, - {"pg_use_binary_copy", "postgres_scanner"}, - {"pg_experimental_filter_pushdown", "postgres_scanner"}, + {"pg_array_as_varchar", "postgres_scanner"}, {"pg_connection_cache", "postgres_scanner"}, {"pg_connection_limit", "postgres_scanner"}, + {"pg_debug_show_queries", "postgres_scanner"}, + {"pg_experimental_filter_pushdown", "postgres_scanner"}, {"pg_pages_per_task", "postgres_scanner"}, - {"pg_array_as_varchar", "postgres_scanner"}, + {"pg_use_binary_copy", "postgres_scanner"}, {"s3_access_key_id", "httpfs"}, {"s3_endpoint", "httpfs"}, {"s3_region", "httpfs"}, @@ -2425,9 +2466,9 @@ static constexpr ExtensionEntry EXTENSION_COLLATIONS[] = { // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb static constexpr ExtensionEntry EXTENSION_FILE_PREFIXES[] = { - {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"}, {"s3a://", "httpfs"}, - {"s3n://", "httpfs"}, {"gcs://", "httpfs"}, {"gs://", "httpfs"}, {"r2://", "httpfs"} // , {"azure://", "azure"} -}; // END_OF_EXTENSION_FILE_PREFIXES + {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"}, {"s3a://", "httpfs"}, + {"s3n://", "httpfs"}, {"gcs://", "httpfs"}, {"gs://", "httpfs"}, {"r2://", "httpfs"}, + {"azure://", "azure"}, {"az://", "azure"}, {"abfss://", "azure"}}; // END_OF_EXTENSION_FILE_PREFIXES // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb @@ -2455,13 +2496,9 @@ static constexpr ExtensionEntry EXTENSION_SECRET_PROVIDERS[] = { {"azure/config", "azure"}, {"azure/credential_chain", "azure"}}; // EXTENSION_SECRET_PROVIDERS static constexpr const char *AUTOLOADABLE_EXTENSIONS[] = { - // "azure", - "arrow", "aws", "autocomplete", "excel", "fts", "httpfs", - // "inet", - // "icu", - "json", "parquet", "postgres_scanner", - // "spatial", TODO: table function isnt always autoloaded so test fails - "sqlsmith", "sqlite_scanner", "tpcds", "tpch"}; // END_OF_AUTOLOADABLE_EXTENSIONS + "aws", "azure", "autocomplete", "excel", "fts", "httpfs", "inet", + "icu", "json", "parquet", "sqlite_scanner", "sqlsmith", "postgres_scanner", "tpcds", + "tpch"}; // END_OF_AUTOLOADABLE_EXTENSIONS } // namespace duckdb @@ -2541,6 +2578,22 @@ class ExtensionHelper { static string GetExtensionName(const string &extension); static bool IsFullPath(const string &extension); + //! Lookup a name + type in an ExtensionFunctionEntry list + template + static vector> + FindExtensionInFunctionEntries(const string &name, const ExtensionFunctionEntry (&entries)[N]) { + auto lcase = StringUtil::Lower(name); + + vector> result; + for (idx_t i = 0; i < N; i++) { + auto &element = entries[i]; + if (element.name == lcase) { + result.push_back(make_pair(element.extension, element.type)); + } + } + return result; + } + //! Lookup a name in an ExtensionEntry list template static string FindExtensionInEntries(const string &name, const ExtensionEntry (&entries)[N]) { @@ -2578,6 +2631,8 @@ class ExtensionHelper { const string &extension_name); static string AddExtensionInstallHintToErrorMsg(ClientContext &context, const string &base_error, const string &extension_name); + static string AddExtensionInstallHintToErrorMsg(DBConfig &config, const string &base_error, + const string &extension_name); //! For tagged releases we use the tag, else we use the git commit hash static const string GetVersionDirectoryName(); @@ -3214,7 +3269,7 @@ inline void DeserializationData::Unset() { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/options/csv_reader_options.hpp +// duckdb/execution/operator/csv_scanner/csv_reader_options.hpp // // //===----------------------------------------------------------------------===// @@ -3224,7 +3279,7 @@ inline void DeserializationData::Unset() { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer.hpp +// duckdb/execution/operator/csv_scanner/csv_buffer.hpp // // //===----------------------------------------------------------------------===// @@ -3235,7 +3290,7 @@ inline void DeserializationData::Unset() { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/buffer_manager/csv_file_handle.hpp +// duckdb/execution/operator/csv_scanner/csv_file_handle.hpp // // //===----------------------------------------------------------------------===// @@ -3947,6 +4002,9 @@ class ColumnDataAllocator { } return total_size; } + idx_t AllocationSize() const { + return allocated_size; + } public: void AllocateData(idx_t size, uint32_t &block_id, uint32_t &offset, ChunkManagementState *chunk_state); @@ -3990,6 +4048,8 @@ class ColumnDataAllocator { bool shared = false; //! Lock used in case this ColumnDataAllocator is shared across threads mutex lock; + //! Total allocated size + idx_t allocated_size = 0; }; } // namespace duckdb @@ -4096,7 +4156,7 @@ class PartitionedColumnData { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -4675,7 +4735,7 @@ class Index { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } @@ -5191,6 +5251,10 @@ class RowGroup : public SegmentBase { void GetColumnSegmentInfo(idx_t row_group_index, vector &result); + idx_t GetAllocationSize() const { + return allocation_size; + } + void Verify(); void NextVector(CollectionScanState &state); @@ -5224,6 +5288,7 @@ class RowGroup : public SegmentBase { unique_ptr[]> is_loaded; vector deletes_pointers; atomic deletes_is_loaded; + idx_t allocation_size; }; } // namespace duckdb @@ -5244,7 +5309,7 @@ struct ColumnSegmentState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -5301,7 +5366,7 @@ struct AnalyzeState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -5317,7 +5382,7 @@ struct CompressionState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -5338,7 +5403,7 @@ struct CompressedSegmentState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -5358,7 +5423,7 @@ struct CompressionAppendState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -5580,8 +5645,8 @@ class ColumnSegment : public SegmentBase { //! Fetch a value of the specific row id and append it to the result void FetchRow(ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx); - static idx_t FilterSelection(SelectionVector &sel, Vector &result, const TableFilter &filter, - idx_t &approved_tuple_count, ValidityMask &mask); + static idx_t FilterSelection(SelectionVector &sel, Vector &vector, UnifiedVectorFormat &vdata, + const TableFilter &filter, idx_t scan_count, idx_t &approved_tuple_count); //! Skip a scan forward to the row_index specified in the scan state void Skip(ColumnScanState &state); @@ -6260,6 +6325,9 @@ class SegmentTree { } idx_t GetSegmentCount() { auto l = Lock(); + return GetSegmentCount(l); + } + idx_t GetSegmentCount(SegmentLock &l) { return nodes.size(); } //! Gets a pointer to the nth segment. Negative numbers start from the back. @@ -6398,9 +6466,6 @@ class SegmentTree { if (nodes.empty()) { return false; } - D_ASSERT(!nodes.empty()); - D_ASSERT(row_number >= nodes[0].row_start); - D_ASSERT(row_number < nodes.back().row_start + nodes.back().node->count); idx_t lower = 0; idx_t upper = nodes.size() - 1; // binary search to find the node @@ -6606,8 +6671,9 @@ class RowGroupCollection { //! Initialize an append of a variable number of rows. FinalizeAppend must be called after appending is done. void InitializeAppend(TableAppendState &state); - //! Initialize an append with a known number of rows. FinalizeAppend should not be called after appending is done. - void InitializeAppend(TransactionData transaction, TableAppendState &state, idx_t append_count); + //! Initialize an append with a variable number of rows. FinalizeAppend should not be called after appending is + //! done. + void InitializeAppend(TransactionData transaction, TableAppendState &state); //! Appends to the row group collection. Returns true if a new row group has been created to append to bool Append(DataChunk &chunk, TableAppendState &state); //! FinalizeAppend flushes an append with a variable number of rows. @@ -6656,6 +6722,10 @@ class RowGroupCollection { return *info; } + idx_t GetAllocationSize() const { + return allocation_size; + } + private: bool IsEmpty(SegmentLock &) const; @@ -6673,6 +6743,8 @@ class RowGroupCollection { shared_ptr row_groups; //! Table statistics TableStatistics stats; + //! Allocation size, only tracked for appends + idx_t allocation_size; }; } // namespace duckdb @@ -6996,9 +7068,11 @@ class DataTable { //! Fetches an append lock void AppendLock(TableAppendState &state); //! Begin appending structs to this table, obtaining necessary locks, etc - void InitializeAppend(DuckTransaction &transaction, TableAppendState &state, idx_t append_count); + void InitializeAppend(DuckTransaction &transaction, TableAppendState &state); //! Append a chunk to the table using the AppendState obtained from InitializeAppend void Append(DataChunk &chunk, TableAppendState &state); + //! Finalize an append + void FinalizeAppend(DuckTransaction &transaction, TableAppendState &state); //! Commit the append void CommitAppend(transaction_t commit_id, idx_t row_start, idx_t count); //! Write a segment of the table to the WAL @@ -7345,10 +7419,18 @@ class ExpressionIterator { static void EnumerateExpression(unique_ptr &expr, const std::function &callback); +}; - static void EnumerateTableRefChildren(BoundTableRef &ref, const std::function &callback); - static void EnumerateQueryNodeChildren(BoundQueryNode &node, - const std::function &callback); +class BoundNodeVisitor { +public: + virtual void VisitBoundQueryNode(BoundQueryNode &op); + virtual void VisitBoundTableRef(BoundTableRef &ref); + virtual void VisitExpression(unique_ptr &expression); + +protected: + // The VisitExpressionChildren method is called at the end of every call to VisitExpression to recursively visit all + // expressions in an expression tree. It can be overloaded to prevent automatically visiting the entire tree. + virtual void VisitExpressionChildren(Expression &expression); }; } // namespace duckdb @@ -8733,7 +8815,8 @@ struct CSVReaderOptions { LogicalType::BOOLEAN, LogicalType::SQLNULL}; //! In case the sniffer found a mismatch error from user defined types or dialect string sniffer_user_mismatch_error; - + //! In case the sniffer found a mismatch error from user defined types or dialect + vector was_type_manually_set; //===--------------------------------------------------------------------===// // ReadCSVOptions //===--------------------------------------------------------------------===// @@ -8818,6 +8901,8 @@ struct CSVReaderOptions { vector &names); string ToString() const; + //! If the type for column with idx i was manually set + bool WasTypeManuallySet(idx_t i) const; }; } // namespace duckdb @@ -9997,6 +10082,8 @@ struct CreateViewInfo : public CreateInfo { vector types; //! Names of the query vector names; + //! Comments on columns of the query. Note: vector can be empty when no comments are set + vector column_comments; //! The SelectStatement of the view unique_ptr query; @@ -10063,7 +10150,7 @@ struct ExtraDropInfo { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } @@ -10287,7 +10374,7 @@ class DefaultTypeGenerator : public DefaultGenerator { -#if defined(GENERATED_EXTENSION_HEADERS) and !defined(DUCKDB_AMALGAMATION) +#if defined(GENERATED_EXTENSION_HEADERS) && !defined(DUCKDB_AMALGAMATION) #include "generated_extension_headers.hpp" @@ -10349,6 +10436,7 @@ class AttachedDatabase : public CatalogEntry { ~AttachedDatabase() override; void Initialize(); + void Close(); Catalog &ParentCatalog() override; StorageManager &GetStorageManager(); @@ -10366,6 +10454,7 @@ class AttachedDatabase : public CatalogEntry { bool IsInitialDatabase() const; void SetInitialDatabase(); + static bool NameIsReserved(const string &name); static string ExtractDatabaseName(const string &dbpath, FileSystem &fs); private: @@ -10376,6 +10465,7 @@ class AttachedDatabase : public CatalogEntry { AttachedDatabaseType type; optional_ptr parent_catalog; bool is_initial_database = false; + bool is_closed = false; }; } // namespace duckdb @@ -10449,6 +10539,7 @@ class Catalog; class CatalogSet; class ClientContext; class DatabaseInstance; +class TaskScheduler; //! The DatabaseManager is a class that sits at the root of all attached databases class DatabaseManager { @@ -10492,7 +10583,7 @@ class DatabaseManager { vector> GetDatabases(ClientContext &context); //! Removes all databases from the catalog set. This is necessary for the database instance's destructor, //! as the database manager has to be alive when destroying the catalog set objects. - void ResetDatabases(); + void ResetDatabases(unique_ptr &scheduler); transaction_t GetNewQueryNumber() { return current_query_number++; @@ -11072,14 +11163,52 @@ void Catalog::AutoloadExtensionByConfigName(ClientContext &context, const string throw Catalog::UnrecognizedConfigurationError(context, configuration_name); } +static bool IsAutoloadableFunction(CatalogType type) { + return (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY || + type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY); +} + +static bool CompareCatalogTypes(CatalogType type_a, CatalogType type_b) { + if (type_a == type_b) { + // Types are same + return true; + } + if (!IsAutoloadableFunction(type_a)) { + D_ASSERT(IsAutoloadableFunction(type_b)); + // Make sure that `type_a` is an autoloadable function + return CompareCatalogTypes(type_b, type_a); + } + if (type_a == CatalogType::TABLE_FUNCTION_ENTRY) { + // These are all table functions + return type_b == CatalogType::TABLE_MACRO_ENTRY || type_b == CatalogType::PRAGMA_FUNCTION_ENTRY; + } else if (type_a == CatalogType::SCALAR_FUNCTION_ENTRY) { + // These are all scalar functions + return type_b == CatalogType::MACRO_ENTRY; + } else if (type_a == CatalogType::PRAGMA_FUNCTION_ENTRY) { + // These are all table functions + return type_b == CatalogType::TABLE_MACRO_ENTRY || type_b == CatalogType::TABLE_FUNCTION_ENTRY; + } + return false; +} + bool Catalog::AutoLoadExtensionByCatalogEntry(DatabaseInstance &db, CatalogType type, const string &entry_name) { #ifndef DUCKDB_DISABLE_EXTENSION_LOAD auto &dbconfig = DBConfig::GetConfig(db); if (dbconfig.options.autoload_known_extensions) { string extension_name; - if (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY || - type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY) { - extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_FUNCTIONS); + if (IsAutoloadableFunction(type)) { + auto lookup_result = ExtensionHelper::FindExtensionInFunctionEntries(entry_name, EXTENSION_FUNCTIONS); + if (lookup_result.empty()) { + return false; + } + for (auto &function : lookup_result) { + auto function_type = function.second; + // FIXME: what if there are two functions with the same name, from different extensions? + if (CompareCatalogTypes(type, function_type)) { + extension_name = function.first; + break; + } + } } else if (type == CatalogType::COPY_FUNCTION_ENTRY) { extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS); } else if (type == CatalogType::TYPE_ENTRY) { @@ -11136,7 +11265,42 @@ CatalogException Catalog::CreateMissingEntryException(ClientContext &context, co string extension_name; if (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY || type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY) { - extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_FUNCTIONS); + auto lookup_result = ExtensionHelper::FindExtensionInFunctionEntries(entry_name, EXTENSION_FUNCTIONS); + do { + if (lookup_result.empty()) { + break; + } + vector other_types; + string extension_for_error; + for (auto &function : lookup_result) { + auto function_type = function.second; + if (CompareCatalogTypes(type, function_type)) { + extension_name = function.first; + break; + } + extension_for_error = function.first; + other_types.push_back(CatalogTypeToString(function_type)); + } + if (!extension_name.empty()) { + break; + } + if (other_types.size() == 1) { + auto &function_type = other_types[0]; + auto error = + CatalogException("%s with name \"%s\" is not in the catalog, a function by this name exists " + "in the %s extension, but it's of a different type, namely %s", + CatalogTypeToString(type), entry_name, extension_for_error, function_type); + return error; + } else { + D_ASSERT(!other_types.empty()); + auto list_of_types = StringUtil::Join(other_types, ", "); + auto error = + CatalogException("%s with name \"%s\" is not in the catalog, functions with this name exist " + "in the %s extension, but they are of different types, namely %s", + CatalogTypeToString(type), entry_name, extension_for_error, list_of_types); + return error; + } + } while (false); } else if (type == CatalogType::TYPE_ENTRY) { extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES); } else if (type == CatalogType::COPY_FUNCTION_ENTRY) { @@ -11260,17 +11424,28 @@ CatalogEntryLookup Catalog::TryLookupEntry(ClientContext &context, CatalogType t QueryErrorContext error_context) { auto entries = GetCatalogEntries(context, catalog, schema); vector lookups; + vector final_lookups; lookups.reserve(entries.size()); for (auto &entry : entries) { + optional_ptr catalog_entry; if (if_not_found == OnEntryNotFound::RETURN_NULL) { - auto catalog_entry = Catalog::GetCatalogEntry(context, entry.catalog); - if (!catalog_entry) { - return {nullptr, nullptr, ErrorData()}; - } - lookups.emplace_back(*catalog_entry, entry.schema); + catalog_entry = Catalog::GetCatalogEntry(context, entry.catalog); } else { - lookups.emplace_back(Catalog::GetCatalog(context, entry.catalog), entry.schema); + catalog_entry = &Catalog::GetCatalog(context, entry.catalog); + } + if (!catalog_entry) { + return {nullptr, nullptr, ErrorData()}; } + D_ASSERT(catalog_entry); + auto lookup_behavior = catalog_entry->CatalogTypeLookupRule(type); + if (lookup_behavior == CatalogLookupBehavior::STANDARD) { + lookups.emplace_back(*catalog_entry, entry.schema); + } else if (lookup_behavior == CatalogLookupBehavior::LOWER_PRIORITY) { + final_lookups.emplace_back(*catalog_entry, entry.schema); + } + } + for (auto &lookup : final_lookups) { + lookups.emplace_back(std::move(lookup)); } return Catalog::TryLookupEntry(context, lookups, type, name, if_not_found, error_context); } @@ -13544,7 +13719,7 @@ class StorageManager { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -13688,7 +13863,7 @@ struct PartialBlock { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } }; @@ -14918,6 +15093,53 @@ class TransactionException : public Exception { } // namespace duckdb +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/parser/parsed_data/comment_on_column_info.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + + + + +namespace duckdb { +class ClientContext; +class CatalogEntry; + +struct SetColumnCommentInfo : public AlterInfo { +public: + static constexpr const ParseInfoType TYPE = ParseInfoType::COMMENT_ON_COLUMN_INFO; + +public: + SetColumnCommentInfo(); + SetColumnCommentInfo(string catalog, string schema, string name, string column_name, Value comment_value, + OnEntryNotFound if_not_found); + + //! The resolved Catalog Type + CatalogType catalog_entry_type; + + //! name of the column to comment on + string column_name; + //! The comment, can be NULL or a string + Value comment_value; + +public: + optional_ptr TryResolveCatalogEntry(ClientContext &context); + unique_ptr Copy() const override; + CatalogType GetCatalogType() const override; + + void Serialize(Serializer &serializer) const override; + static unique_ptr Deserialize(Deserializer &deserializer); +}; + +} // namespace duckdb + namespace duckdb { @@ -15056,6 +15278,13 @@ unique_ptr DuckTableEntry::GetStatistics(ClientContext &context, unique_ptr DuckTableEntry::AlterEntry(ClientContext &context, AlterInfo &info) { D_ASSERT(!internal); + + // Column comments have a special alter type + if (info.type == AlterType::SET_COLUMN_COMMENT) { + auto &comment_on_column_info = info.Cast(); + return SetColumnComment(context, comment_on_column_info); + } + if (info.type != AlterType::ALTER_TABLE) { throw CatalogException("Can only modify table with ALTER TABLE statement"); } @@ -15104,10 +15333,6 @@ unique_ptr DuckTableEntry::AlterEntry(ClientContext &context, Alte auto &drop_not_null_info = table_info.Cast(); return DropNotNull(context, drop_not_null_info); } - case AlterTableType::SET_COLUMN_COMMENT: { - auto &column_comment_info = table_info.Cast(); - return SetColumnComment(context, column_comment_info); - } default: throw InternalException("Unrecognized alter table type!"); } @@ -15569,7 +15794,7 @@ unique_ptr DuckTableEntry::SetColumnComment(ClientContext &context for (auto &col : columns.Logical()) { auto copy = col.Copy(); if (default_idx == col.Logical()) { - copy.SetComment(info.comment); + copy.SetComment(info.comment_value); } create_info->columns.AddColumn(std::move(copy)); } @@ -16038,6 +16263,7 @@ string SchemaCatalogEntry::ToSQL() const { + // LICENSE_CHANGE_BEGIN // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3 // See the end of this file for a list @@ -20916,7 +21142,7 @@ class NumericHelper { template static int SignedLength(SIGNED value) { int sign = -(value < 0); - UNSIGNED unsigned_value = (value ^ sign) - sign; + UNSIGNED unsigned_value = UnsafeNumericCast((value ^ sign) - sign); return UnsignedLength(unsigned_value) - sign; } @@ -20927,16 +21153,16 @@ class NumericHelper { // Integer division is slow so do it for a group of two digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". - auto index = static_cast((value % 100) * 2); + auto index = NumericCast((value % 100) * 2); value /= 100; *--ptr = duckdb_fmt::internal::data::digits[index + 1]; *--ptr = duckdb_fmt::internal::data::digits[index]; } if (value < 10) { - *--ptr = static_cast('0' + value); + *--ptr = NumericCast('0' + value); return ptr; } - auto index = static_cast(value * 2); + auto index = NumericCast(value * 2); *--ptr = duckdb_fmt::internal::data::digits[index + 1]; *--ptr = duckdb_fmt::internal::data::digits[index]; return ptr; @@ -20945,7 +21171,7 @@ class NumericHelper { template static string_t FormatSigned(SIGNED value, Vector &vector) { int sign = -(value < 0); - UNSIGNED unsigned_value = UNSIGNED(value ^ sign) - sign; + UNSIGNED unsigned_value = UnsafeNumericCast(UNSIGNED(value ^ sign) - sign); int length = UnsignedLength(unsigned_value) - sign; string_t result = StringVector::EmptyString(vector, length); auto dataptr = result.GetDataWriteable(); @@ -21123,7 +21349,7 @@ struct HugeintToStringCast { // the remainder is small (i.e. less than 10000000000000000) ptr = NumericHelper::FormatUnsigned(remainder, ptr); - int format_length = startptr - ptr; + int format_length = UnsafeNumericCast(startptr - ptr); // pad with zero for (int i = format_length; i < 17; i++) { *--ptr = '0'; @@ -21283,9 +21509,9 @@ struct DateToStringCast { ptr[0] = '-'; if (date[i] < 10) { ptr[1] = '0'; - ptr[2] = '0' + date[i]; + ptr[2] = '0' + UnsafeNumericCast(date[i]); } else { - auto index = static_cast(date[i] * 2); + auto index = UnsafeNumericCast(date[i] * 2); ptr[1] = duckdb_fmt::internal::data::digits[index]; ptr[2] = duckdb_fmt::internal::data::digits[index + 1]; } @@ -21313,7 +21539,7 @@ struct TimeToStringCast { } trailing_zeros++; } - return trailing_zeros; + return UnsafeNumericCast(trailing_zeros); } static idx_t Length(int32_t time[], char micro_buffer[]) { @@ -21340,9 +21566,9 @@ struct TimeToStringCast { D_ASSERT(value >= 0 && value <= 99); if (value < 10) { ptr[0] = '0'; - ptr[1] = '0' + value; + ptr[1] = '0' + UnsafeNumericCast(value); } else { - auto index = static_cast(value * 2); + auto index = UnsafeNumericCast(value * 2); ptr[0] = duckdb_fmt::internal::data::digits[index]; ptr[1] = duckdb_fmt::internal::data::digits[index + 1]; } @@ -21378,7 +21604,7 @@ struct IntervalToStringCast { } static void FormatTwoDigits(int64_t value, char buffer[], idx_t &length) { - TimeToStringCast::FormatTwoDigits(buffer + length, value); + TimeToStringCast::FormatTwoDigits(buffer + length, UnsafeNumericCast(value)); length += 2; } @@ -21450,7 +21676,8 @@ struct IntervalToStringCast { FormatTwoDigits(sec, buffer, length); if (micros != 0) { buffer[length++] = '.'; - auto trailing_zeros = TimeToStringCast::FormatMicros(micros, buffer + length); + auto trailing_zeros = + TimeToStringCast::FormatMicros(UnsafeNumericCast(micros), buffer + length); length += 6 - trailing_zeros; } } else if (length == 0) { @@ -21990,6 +22217,7 @@ static void BindExtraColumns(TableCatalogEntry &table, LogicalGet &get, LogicalP static bool TypeSupportsRegularUpdate(const LogicalType &type) { switch (type.id()) { case LogicalTypeId::LIST: + case LogicalTypeId::ARRAY: case LogicalTypeId::MAP: case LogicalTypeId::UNION: // lists and maps and unions don't support updates directly @@ -22206,6 +22434,8 @@ string TypeCatalogEntry::ToSQL() const { + + #include namespace duckdb { @@ -22219,6 +22449,7 @@ void ViewCatalogEntry::Initialize(CreateViewInfo &info) { this->sql = info.sql; this->internal = info.internal; this->comment = info.comment; + this->column_comments = info.column_comments; } ViewCatalogEntry::ViewCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateViewInfo &info) @@ -22237,11 +22468,36 @@ unique_ptr ViewCatalogEntry::GetInfo() const { result->types = types; result->temporary = temporary; result->comment = comment; + result->column_comments = column_comments; return std::move(result); } unique_ptr ViewCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) { D_ASSERT(!internal); + + // Column comments have a special alter type + if (info.type == AlterType::SET_COLUMN_COMMENT) { + auto &comment_on_column_info = info.Cast(); + auto copied_view = Copy(context); + + for (idx_t i = 0; i < names.size(); i++) { + const auto &col_name = names[i]; + if (col_name == comment_on_column_info.column_name) { + auto &copied_view_entry = copied_view->Cast(); + + // If vector is empty, we need to initialize it on setting here + if (copied_view_entry.column_comments.empty()) { + copied_view_entry.column_comments = vector(copied_view_entry.types.size()); + } + + copied_view_entry.column_comments[i] = comment_on_column_info.comment_value; + return copied_view; + } + } + throw BinderException("View \"%s\" does not have a column with name \"%s\"", name, + comment_on_column_info.column_name); + } + if (info.type != AlterType::ALTER_VIEW) { throw CatalogException("Can only modify view with ALTER VIEW statement"); } @@ -24241,6 +24497,9 @@ static DefaultMacro internal_macros[] = { // date functions {DEFAULT_SCHEMA, "date_add", {"date", "interval", nullptr}, "date + interval"}, + // regexp functions + {DEFAULT_SCHEMA, "regexp_split_to_table", {"text", "pattern", nullptr}, "unnest(string_split_regex(text, pattern))"}, + // storage helper functions {DEFAULT_SCHEMA, "get_block_size", {"db_name"}, "(SELECT block_size FROM pragma_database_size() WHERE database_name = db_name)"}, @@ -24567,11 +24826,11 @@ static DefaultView internal_views[] = { {"pg_catalog", "pg_tablespace", "SELECT 0 oid, 'pg_default' spcname, 0 spcowner, NULL spcacl, NULL spcoptions"}, {"pg_catalog", "pg_type", "SELECT type_oid oid, format_pg_type(type_name) typname, schema_oid typnamespace, 0 typowner, type_size typlen, false typbyval, CASE WHEN logical_type='ENUM' THEN 'e' else 'b' end typtype, CASE WHEN type_category='NUMERIC' THEN 'N' WHEN type_category='STRING' THEN 'S' WHEN type_category='DATETIME' THEN 'D' WHEN type_category='BOOLEAN' THEN 'B' WHEN type_category='COMPOSITE' THEN 'C' WHEN type_category='USER' THEN 'U' ELSE 'X' END typcategory, false typispreferred, true typisdefined, NULL typdelim, NULL typrelid, NULL typsubscript, NULL typelem, NULL typarray, NULL typinput, NULL typoutput, NULL typreceive, NULL typsend, NULL typmodin, NULL typmodout, NULL typanalyze, 'd' typalign, 'p' typstorage, NULL typnotnull, NULL typbasetype, NULL typtypmod, NULL typndims, NULL typcollation, NULL typdefaultbin, NULL typdefault, NULL typacl FROM duckdb_types() WHERE type_size IS NOT NULL;"}, {"pg_catalog", "pg_views", "SELECT schema_name schemaname, view_name viewname, 'duckdb' viewowner, sql definition FROM duckdb_views()"}, - {"information_schema", "columns", "SELECT database_name table_catalog, schema_name table_schema, table_name, column_name, column_index ordinal_position, column_default, CASE WHEN is_nullable THEN 'YES' ELSE 'NO' END is_nullable, data_type, character_maximum_length, NULL character_octet_length, numeric_precision, numeric_precision_radix, numeric_scale, NULL datetime_precision, NULL interval_type, NULL interval_precision, NULL character_set_catalog, NULL character_set_schema, NULL character_set_name, NULL collation_catalog, NULL collation_schema, NULL collation_name, NULL domain_catalog, NULL domain_schema, NULL domain_name, NULL udt_catalog, NULL udt_schema, NULL udt_name, NULL scope_catalog, NULL scope_schema, NULL scope_name, NULL maximum_cardinality, NULL dtd_identifier, NULL is_self_referencing, NULL is_identity, NULL identity_generation, NULL identity_start, NULL identity_increment, NULL identity_maximum, NULL identity_minimum, NULL identity_cycle, NULL is_generated, NULL generation_expression, NULL is_updatable FROM duckdb_columns;"}, + {"information_schema", "columns", "SELECT database_name table_catalog, schema_name table_schema, table_name, column_name, column_index ordinal_position, column_default, CASE WHEN is_nullable THEN 'YES' ELSE 'NO' END is_nullable, data_type, character_maximum_length, NULL character_octet_length, numeric_precision, numeric_precision_radix, numeric_scale, NULL datetime_precision, NULL interval_type, NULL interval_precision, NULL character_set_catalog, NULL character_set_schema, NULL character_set_name, NULL collation_catalog, NULL collation_schema, NULL collation_name, NULL domain_catalog, NULL domain_schema, NULL domain_name, NULL udt_catalog, NULL udt_schema, NULL udt_name, NULL scope_catalog, NULL scope_schema, NULL scope_name, NULL maximum_cardinality, NULL dtd_identifier, NULL is_self_referencing, NULL is_identity, NULL identity_generation, NULL identity_start, NULL identity_increment, NULL identity_maximum, NULL identity_minimum, NULL identity_cycle, NULL is_generated, NULL generation_expression, NULL is_updatable, comment AS COLUMN_COMMENT FROM duckdb_columns;"}, {"information_schema", "schemata", "SELECT database_name catalog_name, schema_name, 'duckdb' schema_owner, NULL default_character_set_catalog, NULL default_character_set_schema, NULL default_character_set_name, sql sql_path FROM duckdb_schemas()"}, - {"information_schema", "tables", "SELECT database_name table_catalog, schema_name table_schema, table_name, CASE WHEN temporary THEN 'LOCAL TEMPORARY' ELSE 'BASE TABLE' END table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'YES' is_insertable_into, 'NO' is_typed, CASE WHEN temporary THEN 'PRESERVE' ELSE NULL END commit_action FROM duckdb_tables() UNION ALL SELECT database_name table_catalog, schema_name table_schema, view_name table_name, 'VIEW' table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'NO' is_insertable_into, 'NO' is_typed, NULL commit_action FROM duckdb_views;"}, + {"information_schema", "tables", "SELECT database_name table_catalog, schema_name table_schema, table_name, CASE WHEN temporary THEN 'LOCAL TEMPORARY' ELSE 'BASE TABLE' END table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'YES' is_insertable_into, 'NO' is_typed, CASE WHEN temporary THEN 'PRESERVE' ELSE NULL END commit_action, comment AS TABLE_COMMENT FROM duckdb_tables() UNION ALL SELECT database_name table_catalog, schema_name table_schema, view_name table_name, 'VIEW' table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'NO' is_insertable_into, 'NO' is_typed, NULL commit_action, comment AS TABLE_COMMENT FROM duckdb_views;"}, {"information_schema", "character_sets", "SELECT NULL character_set_catalog, NULL character_set_schema, 'UTF8' character_set_name, 'UCS' character_repertoire, 'UTF8' form_of_use, current_database() default_collate_catalog, 'pg_catalog' default_collate_schema, 'ucs_basic' default_collate_name;"}, - {"information_schema", "referential_constraints", "SELECT f.database_name constraint_catalog, f.schema_name constraint_schema, concat(f.source, '_', f.target, '_', f.target_column, '_fkey') constraint_name, current_database() unique_constraint_catalog, c.schema_name unique_constraint_schema, concat(c.table_name, '_', f.target_column, '_', CASE WHEN c.constraint_type == 'UNIQUE' THEN 'key' ELSE 'pkey' END) unique_constraint_name, 'NONE' match_option, 'NO ACTION' update_rule, 'NO ACTION' delete_rule FROM duckdb_constraints() c JOIN (SELECT *, name_extract['source'] source, name_extract['target'] target, name_extract['target_column'] target_column FROM (SELECT *, regexp_extract(constraint_text, 'FOREIGN KEY \\(([a-zA-Z_0-9]+)\\) REFERENCES ([a-zA-Z_0-9]+)\\(([a-zA-Z_0-9]+)\\)', ['source', 'target', 'target_column']) name_extract FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY')) f ON name_extract['target'] = c.table_name AND (c.constraint_type = 'UNIQUE' OR c.constraint_type = 'PRIMARY KEY')"}, + {"information_schema", "referential_constraints", "SELECT f.database_name constraint_catalog, f.schema_name constraint_schema, concat(f.source, '_', f.target, '_', f.target_column, '_fkey') constraint_name, current_database() unique_constraint_catalog, c.schema_name unique_constraint_schema, concat(c.table_name, '_', f.target_column, '_', CASE WHEN c.constraint_type == 'UNIQUE' THEN 'key' ELSE 'pkey' END) unique_constraint_name, 'NONE' match_option, 'NO ACTION' update_rule, 'NO ACTION' delete_rule FROM duckdb_constraints() c JOIN (SELECT *, name_extract['source'] as source, name_extract['target'] as target, name_extract['target_column'] as target_column FROM (SELECT *, regexp_extract(constraint_text, 'FOREIGN KEY \\(([a-zA-Z_0-9]+)\\) REFERENCES ([a-zA-Z_0-9]+)\\(([a-zA-Z_0-9]+)\\)', ['source', 'target', 'target_column']) name_extract FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY')) f ON name_extract['target'] = c.table_name AND (c.constraint_type = 'UNIQUE' OR c.constraint_type = 'PRIMARY KEY')"}, {"information_schema", "key_column_usage", "SELECT current_database() constraint_catalog, schema_name constraint_schema, concat(table_name, '_', constraint_column_names[1], CASE constraint_type WHEN 'FOREIGN KEY' THEN '_fkey' WHEN 'PRIMARY KEY' THEN '_pkey' ELSE '_key' END) constraint_name, current_database() table_catalog, schema_name table_schema, table_name, constraint_column_names[1] column_name, 1 ordinal_position, CASE constraint_type WHEN 'FOREIGN KEY' THEN 1 ELSE NULL END position_in_unique_constraint FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY' OR constraint_type = 'PRIMARY KEY' OR constraint_type = 'UNIQUE';"}, {"information_schema", "table_constraints", "SELECT current_database() constraint_catalog, schema_name constraint_schema, concat(table_name, '_', CASE WHEN length(constraint_column_names) > 1 THEN NULL ELSE constraint_column_names[1] || '_' END, CASE constraint_type WHEN 'FOREIGN KEY' THEN 'fkey' WHEN 'PRIMARY KEY' THEN 'pkey' WHEN 'UNIQUE' THEN 'key' WHEN 'CHECK' THEN 'check' WHEN 'NOT NULL' THEN 'not_null' END) constraint_name, current_database() table_catalog, schema_name table_schema, table_name, CASE constraint_type WHEN 'NOT NULL' THEN 'CHECK' ELSE constraint_type END constraint_type, 'NO' is_deferrable, 'NO' initially_deferred, 'YES' enforced, 'YES' nulls_distinct FROM duckdb_constraints() WHERE constraint_type = 'PRIMARY KEY' OR constraint_type = 'FOREIGN KEY' OR constraint_type = 'UNIQUE' OR constraint_type = 'CHECK' OR constraint_type = 'NOT NULL';"}, {nullptr, nullptr, nullptr}}; @@ -24662,9 +24921,7 @@ MangledDependencyName DependencyCatalogSet::ApplyPrefix(const MangledEntryName & bool DependencyCatalogSet::CreateEntry(CatalogTransaction transaction, const MangledEntryName &name, unique_ptr value) { auto new_name = ApplyPrefix(name); - - static const DependencyList EMPTY_DEPENDENCIES; - return set.CreateEntry(transaction, new_name.name, std::move(value), EMPTY_DEPENDENCIES); + return set.CreateEntry(transaction, new_name.name, std::move(value), DependencyList()); } CatalogSet::EntryLookup DependencyCatalogSet::GetEntryDetailed(CatalogTransaction transaction, @@ -24755,19 +25012,16 @@ static void AssertMangledName(const string &mangled_name, idx_t expected_null_by } MangledEntryName::MangledEntryName(const CatalogEntryInfo &info) { - static const auto NULL_BYTE = string(1, '\0'); - auto &type = info.type; auto &schema = info.schema; auto &name = info.name; - this->name = CatalogTypeToString(type) + NULL_BYTE + schema + NULL_BYTE + name; + this->name = CatalogTypeToString(type) + '\0' + schema + '\0' + name; AssertMangledName(this->name, 2); } MangledDependencyName::MangledDependencyName(const MangledEntryName &from, const MangledEntryName &to) { - static const auto NULL_BYTE = string(1, '\0'); - this->name = from.name + NULL_BYTE + to.name; + this->name = from.name + '\0' + to.name; AssertMangledName(this->name, 5); } @@ -26429,7 +26683,11 @@ struct ArrowArrayScanState { public: ArrowScanLocalState &state; + // Hold ownership over the Arrow Arrays owned by DuckDB to allow for zero-copy + shared_ptr owned_data; unordered_map> children; + // Optionally holds the pointer that was used to create the cached dictionary + optional_ptr arrow_dictionary = nullptr; // Cache the (optional) dictionary of this array unique_ptr dictionary; //! Run-end-encoding state @@ -26437,8 +26695,9 @@ struct ArrowArrayScanState { public: ArrowArrayScanState &GetChild(idx_t child_idx); - void AddDictionary(unique_ptr dictionary_p); + void AddDictionary(unique_ptr dictionary_p, ArrowArray *arrow_dict); bool HasDictionary() const; + bool CacheOutdated(ArrowArray *dictionary) const; Vector &GetDictionary(); ArrowRunEndEncodingState &RunEndEncoding() { return run_end_encoding; @@ -26449,6 +26708,10 @@ struct ArrowArrayScanState { // Note: dictionary is not reset // the dictionary should be the same for every array scanned of this column run_end_encoding.Reset(); + for (auto &child : children) { + child.second->Reset(); + } + owned_data.reset(); } }; @@ -26460,9 +26723,6 @@ struct ArrowScanLocalState : public LocalTableFunctionState { public: unique_ptr stream; shared_ptr chunk; - // This vector hold the Arrow Vectors owned by DuckDB to allow for zero-copy - // Note that only DuckDB can release these vectors - unordered_map> arrow_owned_data; idx_t chunk_offset = 0; idx_t batch_index = 0; vector column_ids; @@ -26984,7 +27244,7 @@ AdbcStatusCode ConnectionGetInfo(struct AdbcConnection *connection, const uint32 duckdb::string results = ""; for (size_t i = 0; i < length; i++) { - uint32_t code = info_codes ? info_codes[i] : i; + auto code = duckdb::NumericCast(info_codes ? info_codes[i] : i); auto info_code = ConvertToInfoCode(code); switch (info_code) { case AdbcInfoCode::VENDOR_NAME: { @@ -27597,6 +27857,7 @@ AdbcStatusCode ConnectionGetTableTypes(struct AdbcConnection *connection, struct // specific language governing permissions and limitations // under the License. + // Licensed to the Apache Software Foundation (ASF) under one // or more contributor license agreements. See the NOTICE file // distributed with this work for additional information @@ -28171,7 +28432,7 @@ std::string AdbcDriverManagerDefaultEntrypoint(const std::string &driver) { // if pos == npos this is the entire filename std::string token = filename.substr(prev, pos - prev); // capitalize first letter - token[0] = std::toupper(static_cast(token[0])); + token[0] = duckdb::NumericCast(std::toupper(static_cast(token[0]))); entrypoint += token; @@ -30021,6 +30282,7 @@ AdbcStatusCode BatchToArrayStream(struct ArrowArray *values, struct ArrowSchema + #include #ifdef DUCKDB_DEBUG_ALLOCATION @@ -30112,15 +30374,9 @@ PrivateAllocatorData::~PrivateAllocatorData() { //===--------------------------------------------------------------------===// // Allocator //===--------------------------------------------------------------------===// -#ifdef USE_JEMALLOC -Allocator::Allocator() - : Allocator(JemallocExtension::Allocate, JemallocExtension::Free, JemallocExtension::Reallocate, nullptr) { -} -#else Allocator::Allocator() : Allocator(Allocator::DefaultAllocate, Allocator::DefaultFree, Allocator::DefaultReallocate, nullptr) { } -#endif Allocator::Allocator(allocate_function_ptr_t allocate_function_p, free_function_ptr_t free_function_p, reallocate_function_ptr_t reallocate_function_p, unique_ptr private_data_p) @@ -30153,7 +30409,7 @@ data_ptr_t Allocator::AllocateData(idx_t size) { private_data->debug_info->AllocateData(result, size); #endif if (!result) { - throw OutOfMemoryException("Failed to allocate block of %llu bytes", size); + throw OutOfMemoryException("Failed to allocate block of %llu bytes (bad allocation)", size); } return result; } @@ -30186,11 +30442,36 @@ data_ptr_t Allocator::ReallocateData(data_ptr_t pointer, idx_t old_size, idx_t s private_data->debug_info->ReallocateData(pointer, new_pointer, old_size, size); #endif if (!new_pointer) { - throw OutOfMemoryException("Failed to re-allocate block of %llu bytes", size); + throw OutOfMemoryException("Failed to re-allocate block of %llu bytes (bad allocation)", size); } return new_pointer; } +data_ptr_t Allocator::DefaultAllocate(PrivateAllocatorData *private_data, idx_t size) { +#ifdef USE_JEMALLOC + return JemallocExtension::Allocate(private_data, size); +#else + return data_ptr_cast(malloc(size)); +#endif +} + +void Allocator::DefaultFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size) { +#ifdef USE_JEMALLOC + JemallocExtension::Free(private_data, pointer, size); +#else + free(pointer); +#endif +} + +data_ptr_t Allocator::DefaultReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size, + idx_t size) { +#ifdef USE_JEMALLOC + return JemallocExtension::Reallocate(private_data, pointer, old_size, size); +#else + return data_ptr_cast(realloc(pointer, size)); +#endif +} + shared_ptr &Allocator::DefaultAllocatorReference() { static shared_ptr DEFAULT_ALLOCATOR = make_shared(); return DEFAULT_ALLOCATOR; @@ -30206,6 +30487,12 @@ void Allocator::ThreadFlush(idx_t threshold) { #endif } +void Allocator::FlushAll() { +#ifdef USE_JEMALLOC + JemallocExtension::FlushAll(); +#endif +} + //===--------------------------------------------------------------------===// // Debug Info (extended) //===--------------------------------------------------------------------===// @@ -30581,6 +30868,59 @@ void ArrowBoolData::Finalize(ArrowAppendData &append_data, const LogicalType &ty +namespace duckdb { + +struct ArrowFixedSizeListData { +public: + static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity); + static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size); + static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result); +}; + +} // namespace duckdb + + +namespace duckdb { + +//===--------------------------------------------------------------------===// +// Arrays +//===--------------------------------------------------------------------===// +void ArrowFixedSizeListData::Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) { + auto &child_type = ArrayType::GetChildType(type); + auto array_size = ArrayType::GetSize(type); + auto child_buffer = ArrowAppender::InitializeChild(child_type, capacity * array_size, result.options); + result.child_data.push_back(std::move(child_buffer)); +} + +void ArrowFixedSizeListData::Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, + idx_t input_size) { + UnifiedVectorFormat format; + input.ToUnifiedFormat(input_size, format); + idx_t size = to - from; + AppendValidity(append_data, format, from, to); + + auto array_size = ArrayType::GetSize(input.GetType()); + auto &child_vector = ArrayVector::GetEntry(input); + auto &child_data = *append_data.child_data[0]; + child_data.append_vector(child_data, child_vector, from * array_size, to * array_size, size * array_size); + append_data.row_count += size; +} + +void ArrowFixedSizeListData::Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) { + result->n_buffers = 1; + auto &child_type = ArrayType::GetChildType(type); + ArrowAppender::AddChildren(append_data, 1); + result->children = append_data.child_pointers.data(); + result->n_children = 1; + append_data.child_arrays[0] = *ArrowAppender::FinalizeChild(child_type, std::move(append_data.child_data[0])); +} + +} // namespace duckdb + + + + + @@ -30732,6 +31072,7 @@ void ArrowStructData::Finalize(ArrowAppendData &append_data, const LogicalType & + namespace duckdb { //===--------------------------------------------------------------------===// @@ -30792,7 +31133,7 @@ void ArrowUnionData::Append(ArrowAppendData &append_data, Vector &input, idx_t f child_vectors[child_idx].SetValue(input_idx, child_idx == tag ? resolved_value : Value(nullptr)); } - types_buffer.data()[input_idx] = tag; + types_buffer.data()[input_idx] = NumericCast(tag); } for (idx_t child_idx = 0; child_idx < child_vectors.size(); child_idx++) { @@ -30874,13 +31215,13 @@ struct ArrowEnumData : public ArrowScalarBaseData { // append the offset data auto current_offset = last_offset + string_length; - offset_data[offset_idx] = current_offset; + offset_data[offset_idx] = UnsafeNumericCast(current_offset); // resize the string buffer if required, and write the string data append_data.aux_buffer.resize(current_offset); WriteData(append_data.aux_buffer.data() + last_offset, data[i]); - last_offset = current_offset; + last_offset = UnsafeNumericCast(current_offset); } append_data.row_count += size; } @@ -30909,6 +31250,7 @@ struct ArrowEnumData : public ArrowScalarBaseData { + namespace duckdb { template @@ -30986,7 +31328,7 @@ struct ArrowListData { offset_data[offset_idx] = last_offset; for (idx_t k = 0; k < list_length; k++) { - child_sel.push_back(data[source_idx].offset + k); + child_sel.push_back(UnsafeNumericCast(data[source_idx].offset + k)); } } } @@ -31182,13 +31524,13 @@ struct ArrowVarcharData { "%u but the offset of %lu exceeds this.", NumericLimits::Maximum(), current_offset); } - offset_data[offset_idx] = current_offset; + offset_data[offset_idx] = UnsafeNumericCast(current_offset); // resize the string buffer if required, and write the string data append_data.aux_buffer.resize(current_offset); OP::WriteData(append_data.aux_buffer.data() + last_offset, data[source_idx]); - last_offset = current_offset; + last_offset = UnsafeNumericCast(current_offset); } append_data.row_count += size; } @@ -31432,6 +31774,9 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic case LogicalTypeId::STRUCT: InitializeAppenderForType(append_data); break; + case LogicalTypeId::ARRAY: + InitializeAppenderForType(append_data); + break; case LogicalTypeId::LIST: { if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) { InitializeAppenderForType>(append_data); @@ -31441,11 +31786,8 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic break; } case LogicalTypeId::MAP: - if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) { - InitializeAppenderForType>(append_data); - } else { - InitializeAppenderForType>(append_data); - } + // Arrow MapArray only supports 32-bit offsets. There is no LargeMapArray type in Arrow. + InitializeAppenderForType>(append_data); break; default: throw NotImplementedException("Unsupported type in DuckDB -> Arrow Conversion: %s\n", type.ToString()); @@ -31588,7 +31930,7 @@ template string Bit::NumericToBit(T numeric) { auto bit_len = sizeof(T) + 1; auto buffer = make_unsafe_uniq_array(bit_len); - string_t output_str(buffer.get(), bit_len); + string_t output_str(buffer.get(), UnsafeNumericCast(bit_len)); Bit::NumericToBit(numeric, output_str); return output_str.GetString(); } @@ -31898,6 +32240,23 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co } break; } + case LogicalTypeId::ARRAY: { + auto array_size = ArrayType::GetSize(type); + auto &child_type = ArrayType::GetChildType(type); + auto format = "+w:" + to_string(array_size); + root_holder.owned_type_names.push_back(AddName(format)); + child.format = root_holder.owned_type_names.back().get(); + + child.n_children = 1; + root_holder.nested_children.emplace_back(); + root_holder.nested_children.back().resize(1); + root_holder.nested_children_ptr.emplace_back(); + 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); + break; + } case LogicalTypeId::MAP: { SetArrowMapFormat(root_holder, child, type, options); break; @@ -33920,6 +34279,7 @@ void CompressedFile::Close() { stream_data.in_buff_end = nullptr; stream_data.in_buf_size = 0; stream_data.out_buf_size = 0; + stream_data.refresh = false; } int64_t CompressedFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) { @@ -34505,6 +34865,7 @@ const char *ToString(AggregateHandling value); + //===----------------------------------------------------------------------===// // DuckDB // @@ -34586,6 +34947,7 @@ DUCKDB_API DatePartSpecifier GetDatePartSpecifier(const string &specifier); + //===----------------------------------------------------------------------===// @@ -34706,7 +35068,7 @@ struct ExtraTypeInfo { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -34851,8 +35213,8 @@ struct EnumTypeInfo : public ExtraTypeInfo { struct ArrayTypeInfo : public ExtraTypeInfo { LogicalType child_type; - idx_t size; - explicit ArrayTypeInfo(LogicalType child_type_p, idx_t size_p); + uint32_t size; + explicit ArrayTypeInfo(LogicalType child_type_p, uint32_t size_p); public: void Serialize(Serializer &serializer) const override; @@ -37510,9 +37872,12 @@ struct TupleDataPinState { }; struct CombinedListData { + CombinedListData() : combined_validity(STANDARD_VECTOR_SIZE) { + } UnifiedVectorFormat combined_data; - list_entry_t combined_list_entries[STANDARD_VECTOR_SIZE]; buffer_ptr selection_data; + list_entry_t combined_list_entries[STANDARD_VECTOR_SIZE]; + ValidityMask combined_validity; }; struct TupleDataVectorFormat { @@ -38218,7 +38583,7 @@ class PartitionedTupleData { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -38373,94 +38738,6 @@ class RadixPartitionedTupleData : public PartitionedTupleData { -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/parallel/event.hpp -// -// -//===----------------------------------------------------------------------===// - - - - - - - -namespace duckdb { -class Executor; -class Task; - -class Event : public std::enable_shared_from_this { -public: - explicit Event(Executor &executor); - virtual ~Event() = default; - -public: - virtual void Schedule() = 0; - //! Called right after the event is finished - virtual void FinishEvent() { - } - //! Called after the event is entirely finished - virtual void FinalizeFinish() { - } - - void FinishTask(); - void Finish(); - - void AddDependency(Event &event); - bool HasDependencies() const { - return total_dependencies != 0; - } - const vector> &GetParentsVerification() const; - - void CompleteDependency(); - - void SetTasks(vector> tasks); - - void InsertEvent(shared_ptr replacement_event); - - bool IsFinished() const { - return finished; - } - - virtual void PrintPipeline() { - } - - template - TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); - return reinterpret_cast(*this); - } - template - const TARGET &Cast() const { - D_ASSERT(dynamic_cast(this)); - return reinterpret_cast(*this); - } - -protected: - Executor &executor; - //! The current threads working on the event - atomic finished_tasks; - //! The maximum amount of threads that can work on the event - atomic total_tasks; - - //! The amount of completed dependencies - //! The event can only be started after the dependencies have finished executing - atomic finished_dependencies; - //! The total amount of dependencies - idx_t total_dependencies; - - //! The events that depend on this event to run - vector> parents; - //! Raw pointers to the parents (used for verification only) - vector> parents_raw; - - //! Whether or not the event is finished executing - atomic finished; -}; - -} // namespace duckdb @@ -38959,6 +39236,7 @@ class ErrorManager { + //===----------------------------------------------------------------------===// // DuckDB // @@ -39216,6 +39494,16 @@ class WindowExpression : public ParsedExpression { default: throw InternalException("Unrecognized TO in WindowExpression"); } + if (entry.exclude_clause != WindowExcludeMode::NO_OTHER) { + // if we have an explicit EXCLUDE we always need to fill in from/to + if (from.empty()) { + from = "UNBOUNDED PRECEDING"; + } + if (to.empty()) { + to = "CURRENT ROW"; + units = "RANGE"; + } + } if (!from.empty() || !to.empty()) { result += sep + units; @@ -39964,6 +40252,8 @@ const char* EnumUtil::ToChars(AlterType value) { return "ALTER_TABLE_FUNCTION"; case AlterType::SET_COMMENT: return "SET_COMMENT"; + case AlterType::SET_COLUMN_COMMENT: + return "SET_COLUMN_COMMENT"; default: throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value)); } @@ -39995,6 +40285,9 @@ AlterType EnumUtil::FromString(const char *value) { if (StringUtil::Equals(value, "SET_COMMENT")) { return AlterType::SET_COMMENT; } + if (StringUtil::Equals(value, "SET_COLUMN_COMMENT")) { + return AlterType::SET_COLUMN_COMMENT; + } throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); } @@ -40338,6 +40631,34 @@ CTEMaterialize EnumUtil::FromString(const char *value) { throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); } +template<> +const char* EnumUtil::ToChars(CatalogLookupBehavior value) { + switch(value) { + case CatalogLookupBehavior::STANDARD: + return "STANDARD"; + case CatalogLookupBehavior::LOWER_PRIORITY: + return "LOWER_PRIORITY"; + case CatalogLookupBehavior::NEVER_LOOKUP: + return "NEVER_LOOKUP"; + default: + throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value)); + } +} + +template<> +CatalogLookupBehavior EnumUtil::FromString(const char *value) { + if (StringUtil::Equals(value, "STANDARD")) { + return CatalogLookupBehavior::STANDARD; + } + if (StringUtil::Equals(value, "LOWER_PRIORITY")) { + return CatalogLookupBehavior::LOWER_PRIORITY; + } + if (StringUtil::Equals(value, "NEVER_LOOKUP")) { + return CatalogLookupBehavior::NEVER_LOOKUP; + } + throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); +} + template<> const char* EnumUtil::ToChars(CatalogType value) { switch(value) { @@ -42361,6 +42682,44 @@ KeywordCategory EnumUtil::FromString(const char *value) { throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); } +template<> +const char* EnumUtil::ToChars(LimitNodeType value) { + switch(value) { + case LimitNodeType::UNSET: + return "UNSET"; + case LimitNodeType::CONSTANT_VALUE: + return "CONSTANT_VALUE"; + case LimitNodeType::CONSTANT_PERCENTAGE: + return "CONSTANT_PERCENTAGE"; + case LimitNodeType::EXPRESSION_VALUE: + return "EXPRESSION_VALUE"; + case LimitNodeType::EXPRESSION_PERCENTAGE: + return "EXPRESSION_PERCENTAGE"; + default: + throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value)); + } +} + +template<> +LimitNodeType EnumUtil::FromString(const char *value) { + if (StringUtil::Equals(value, "UNSET")) { + return LimitNodeType::UNSET; + } + if (StringUtil::Equals(value, "CONSTANT_VALUE")) { + return LimitNodeType::CONSTANT_VALUE; + } + if (StringUtil::Equals(value, "CONSTANT_PERCENTAGE")) { + return LimitNodeType::CONSTANT_PERCENTAGE; + } + if (StringUtil::Equals(value, "EXPRESSION_VALUE")) { + return LimitNodeType::EXPRESSION_VALUE; + } + if (StringUtil::Equals(value, "EXPRESSION_PERCENTAGE")) { + return LimitNodeType::EXPRESSION_PERCENTAGE; + } + throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); +} + template<> const char* EnumUtil::ToChars(LoadType value) { switch(value) { @@ -42416,8 +42775,6 @@ const char* EnumUtil::ToChars(LogicalOperatorType value) { return "LOGICAL_DISTINCT"; case LogicalOperatorType::LOGICAL_SAMPLE: return "LOGICAL_SAMPLE"; - case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: - return "LOGICAL_LIMIT_PERCENT"; case LogicalOperatorType::LOGICAL_PIVOT: return "LOGICAL_PIVOT"; case LogicalOperatorType::LOGICAL_COPY_DATABASE: @@ -42557,9 +42914,6 @@ LogicalOperatorType EnumUtil::FromString(const char *value) if (StringUtil::Equals(value, "LOGICAL_SAMPLE")) { return LogicalOperatorType::LOGICAL_SAMPLE; } - if (StringUtil::Equals(value, "LOGICAL_LIMIT_PERCENT")) { - return LogicalOperatorType::LOGICAL_LIMIT_PERCENT; - } if (StringUtil::Equals(value, "LOGICAL_PIVOT")) { return LogicalOperatorType::LOGICAL_PIVOT; } @@ -43017,6 +43371,12 @@ const char* EnumUtil::ToChars(MapInvalidReason value) { return "NULL_KEY"; case MapInvalidReason::DUPLICATE_KEY: return "DUPLICATE_KEY"; + case MapInvalidReason::NULL_VALUE_LIST: + return "NULL_VALUE_LIST"; + case MapInvalidReason::NOT_ALIGNED: + return "NOT_ALIGNED"; + case MapInvalidReason::INVALID_PARAMS: + return "INVALID_PARAMS"; default: throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value)); } @@ -43036,6 +43396,15 @@ MapInvalidReason EnumUtil::FromString(const char *value) { if (StringUtil::Equals(value, "DUPLICATE_KEY")) { return MapInvalidReason::DUPLICATE_KEY; } + if (StringUtil::Equals(value, "NULL_VALUE_LIST")) { + return MapInvalidReason::NULL_VALUE_LIST; + } + if (StringUtil::Equals(value, "NOT_ALIGNED")) { + return MapInvalidReason::NOT_ALIGNED; + } + if (StringUtil::Equals(value, "INVALID_PARAMS")) { + return MapInvalidReason::INVALID_PARAMS; + } throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); } @@ -43589,6 +43958,8 @@ const char* EnumUtil::ToChars(ParseInfoType value) { return "VACUUM_INFO"; case ParseInfoType::COMMENT_ON_INFO: return "COMMENT_ON_INFO"; + case ParseInfoType::COMMENT_ON_COLUMN_INFO: + return "COMMENT_ON_COLUMN_INFO"; default: throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value)); } @@ -43638,6 +44009,9 @@ ParseInfoType EnumUtil::FromString(const char *value) { if (StringUtil::Equals(value, "COMMENT_ON_INFO")) { return ParseInfoType::COMMENT_ON_INFO; } + if (StringUtil::Equals(value, "COMMENT_ON_COLUMN_INFO")) { + return ParseInfoType::COMMENT_ON_COLUMN_INFO; + } throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); } @@ -43829,8 +44203,6 @@ const char* EnumUtil::ToChars(PhysicalOperatorType value) return "COPY_TO_FILE"; case PhysicalOperatorType::BATCH_COPY_TO_FILE: return "BATCH_COPY_TO_FILE"; - case PhysicalOperatorType::FIXED_BATCH_COPY_TO_FILE: - return "FIXED_BATCH_COPY_TO_FILE"; case PhysicalOperatorType::RESERVOIR_SAMPLE: return "RESERVOIR_SAMPLE"; case PhysicalOperatorType::STREAMING_SAMPLE: @@ -43949,6 +44321,8 @@ const char* EnumUtil::ToChars(PhysicalOperatorType value) return "RESET"; case PhysicalOperatorType::EXTENSION: return "EXTENSION"; + case PhysicalOperatorType::VERIFY_VECTOR: + return "VERIFY_VECTOR"; case PhysicalOperatorType::CREATE_SECRET: return "CREATE_SECRET"; default: @@ -44003,9 +44377,6 @@ PhysicalOperatorType EnumUtil::FromString(const char *valu if (StringUtil::Equals(value, "BATCH_COPY_TO_FILE")) { return PhysicalOperatorType::BATCH_COPY_TO_FILE; } - if (StringUtil::Equals(value, "FIXED_BATCH_COPY_TO_FILE")) { - return PhysicalOperatorType::FIXED_BATCH_COPY_TO_FILE; - } if (StringUtil::Equals(value, "RESERVOIR_SAMPLE")) { return PhysicalOperatorType::RESERVOIR_SAMPLE; } @@ -44183,6 +44554,9 @@ PhysicalOperatorType EnumUtil::FromString(const char *valu if (StringUtil::Equals(value, "EXTENSION")) { return PhysicalOperatorType::EXTENSION; } + if (StringUtil::Equals(value, "VERIFY_VECTOR")) { + return PhysicalOperatorType::VERIFY_VECTOR; + } if (StringUtil::Equals(value, "CREATE_SECRET")) { return PhysicalOperatorType::CREATE_SECRET; } @@ -44363,6 +44737,29 @@ PreparedParamType EnumUtil::FromString(const char *value) { throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); } +template<> +const char* EnumUtil::ToChars(PreparedStatementMode value) { + switch(value) { + case PreparedStatementMode::PREPARE_ONLY: + return "PREPARE_ONLY"; + case PreparedStatementMode::PREPARE_AND_EXECUTE: + return "PREPARE_AND_EXECUTE"; + default: + throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value)); + } +} + +template<> +PreparedStatementMode EnumUtil::FromString(const char *value) { + if (StringUtil::Equals(value, "PREPARE_ONLY")) { + return PreparedStatementMode::PREPARE_ONLY; + } + if (StringUtil::Equals(value, "PREPARE_AND_EXECUTE")) { + return PreparedStatementMode::PREPARE_AND_EXECUTE; + } + throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); +} + template<> const char* EnumUtil::ToChars(ProfilerPrintFormat value) { switch(value) { @@ -44933,6 +45330,34 @@ SetType EnumUtil::FromString(const char *value) { throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); } +template<> +const char* EnumUtil::ToChars(SettingScope value) { + switch(value) { + case SettingScope::GLOBAL: + return "GLOBAL"; + case SettingScope::LOCAL: + return "LOCAL"; + case SettingScope::INVALID: + return "INVALID"; + default: + throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value)); + } +} + +template<> +SettingScope EnumUtil::FromString(const char *value) { + if (StringUtil::Equals(value, "GLOBAL")) { + return SettingScope::GLOBAL; + } + if (StringUtil::Equals(value, "LOCAL")) { + return SettingScope::LOCAL; + } + if (StringUtil::Equals(value, "INVALID")) { + return SettingScope::INVALID; + } + throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); +} + template<> const char* EnumUtil::ToChars(ShowType value) { switch(value) { @@ -46711,11 +47136,13 @@ string CompressionTypeToString(CompressionType type) { + namespace duckdb { class ConversionException : public Exception { public: DUCKDB_API explicit ConversionException(const string &msg); + DUCKDB_API explicit ConversionException(optional_idx error_location, const string &msg); DUCKDB_API ConversionException(const PhysicalType origType, const PhysicalType newType); DUCKDB_API ConversionException(const LogicalType &origType, const LogicalType &newType); @@ -46723,6 +47150,10 @@ class ConversionException : public Exception { explicit ConversionException(const string &msg, Args... params) : ConversionException(ConstructMessage(msg, params...)) { } + template + explicit ConversionException(optional_idx error_location, const string &msg, Args... params) + : ConversionException(error_location, ConstructMessage(msg, params...)) { + } }; } // namespace duckdb @@ -47261,8 +47692,6 @@ string LogicalOperatorToString(LogicalOperatorType type) { return "TOP_N"; case LogicalOperatorType::LOGICAL_SAMPLE: return "SAMPLE"; - case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: - return "LIMIT_PERCENT"; case LogicalOperatorType::LOGICAL_COPY_TO_FILE: return "COPY_TO_FILE"; case LogicalOperatorType::LOGICAL_COPY_DATABASE: @@ -47468,8 +47897,6 @@ string PhysicalOperatorToString(PhysicalOperatorType type) { return "COPY_TO_FILE"; case PhysicalOperatorType::BATCH_COPY_TO_FILE: return "BATCH_COPY_TO_FILE"; - case PhysicalOperatorType::FIXED_BATCH_COPY_TO_FILE: - return "FIXED_BATCH_COPY_TO_FILE"; case PhysicalOperatorType::LEFT_DELIM_JOIN: return "LEFT_DELIM_JOIN"; case PhysicalOperatorType::RIGHT_DELIM_JOIN: @@ -47574,6 +48001,8 @@ string PhysicalOperatorToString(PhysicalOperatorType type) { return "PIVOT"; case PhysicalOperatorType::COPY_DATABASE: return "COPY_DATABASE"; + case PhysicalOperatorType::VERIFY_VECTOR: + return "VERIFY_VECTOR"; case PhysicalOperatorType::INVALID: break; } @@ -47948,6 +48377,29 @@ CatalogException CatalogException::EntryAlreadyExists(CatalogType type, const st +namespace duckdb { + +ConversionException::ConversionException(const PhysicalType orig_type, const PhysicalType new_type) + : Exception(ExceptionType::CONVERSION, + "Type " + TypeIdToString(orig_type) + " can't be cast as " + TypeIdToString(new_type)) { +} + +ConversionException::ConversionException(const LogicalType &orig_type, const LogicalType &new_type) + : Exception(ExceptionType::CONVERSION, + "Type " + orig_type.ToString() + " can't be cast as " + new_type.ToString()) { +} + +ConversionException::ConversionException(const string &msg) : Exception(ExceptionType::CONVERSION, msg) { +} + +ConversionException::ConversionException(optional_idx error_location, const string &msg) + : Exception(ExceptionType::CONVERSION, msg, Exception::InitializeExtraInfo(error_location)) { +} + +} // namespace duckdb + + + namespace duckdb { @@ -48249,19 +48701,6 @@ void Exception::SetQueryLocation(optional_idx error_location, unordered_map(i); } } @@ -49699,11 +50145,11 @@ shared_ptr EnumTypeInfo::Deserialize(Deserializer &deserializer) auto enum_internal_type = EnumTypeInfo::DictType(values_count); switch (enum_internal_type) { case PhysicalType::UINT8: - return EnumTypeInfoTemplated::Deserialize(deserializer, values_count); + return EnumTypeInfoTemplated::Deserialize(deserializer, NumericCast(values_count)); case PhysicalType::UINT16: - return EnumTypeInfoTemplated::Deserialize(deserializer, values_count); + return EnumTypeInfoTemplated::Deserialize(deserializer, NumericCast(values_count)); case PhysicalType::UINT32: - return EnumTypeInfoTemplated::Deserialize(deserializer, values_count); + return EnumTypeInfoTemplated::Deserialize(deserializer, NumericCast(values_count)); default: throw InternalException("Invalid Physical Type for ENUMs"); } @@ -49746,7 +50192,7 @@ void EnumTypeInfo::Serialize(Serializer &serializer) const { // ArrayTypeInfo //===--------------------------------------------------------------------===// -ArrayTypeInfo::ArrayTypeInfo(LogicalType child_type_p, idx_t size_p) +ArrayTypeInfo::ArrayTypeInfo(LogicalType child_type_p, uint32_t size_p) : ExtraTypeInfo(ExtraTypeInfoType::ARRAY_TYPE_INFO), child_type(std::move(child_type_p)), size(size_p) { } @@ -49911,6 +50357,7 @@ void FileBuffer::Initialize(DebugInitialize initialize) { + namespace duckdb { class ClientContext; @@ -49927,14 +50374,14 @@ class FileOpener { } virtual ~FileOpener() {}; - virtual bool TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info); - virtual bool TryGetCurrentSetting(const string &key, Value &result) = 0; + virtual SettingLookupResult TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info); + virtual SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) = 0; virtual ClientContext *TryGetClientContext() = 0; DUCKDB_API static ClientContext *TryGetClientContext(FileOpener *opener); - DUCKDB_API static bool TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result); - DUCKDB_API static bool TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result, - FileOpenerInfo &info); + DUCKDB_API static SettingLookupResult TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result); + DUCKDB_API static SettingLookupResult TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result, + FileOpenerInfo &info); }; } // namespace duckdb @@ -51575,6 +52022,10 @@ string FilenamePattern::CreateFilename(FileSystem &fs, const string &path, const #undef RemoveDirectory #endif +#ifdef UUID +#undef UUID +#endif + #endif @@ -52629,7 +53080,7 @@ struct SegmentScanState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -52645,7 +53096,7 @@ struct IndexScanState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -52674,10 +53125,6 @@ struct ColumnScanState { bool initialized = false; //! If this segment has already been checked for skipping purposes bool segment_checked = false; - //! The version of the column data that we are scanning. - //! This is used to detect if the ColumnData has been changed out from under us during a scan - //! If this is the case, we re-initialize the scan - idx_t version = 0; //! We initialize one SegmentScanState per segment, however, if scanning a DataChunk requires us to scan over more //! than one Segment, we need to keep the scan states of the previous segments around vector> previous_states; @@ -52867,8 +53314,6 @@ struct TableAppendState { RowGroup *start_row_group; //! The transaction data TransactionData transaction; - //! The remaining append count, only if the append count is known beforehand - idx_t remaining; }; struct LocalAppendState { @@ -53435,6 +53880,7 @@ static constexpr const unsigned char GZIP_FLAG_UNSUPPORTED = + // LICENSE_CHANGE_BEGIN // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7 // See the end of this file for a list @@ -54805,9 +55251,9 @@ struct MiniZStream { } stream.next_in = (const unsigned char *)compressed_data + GZIP_HEADER_MINSIZE; - stream.avail_in = compressed_size - GZIP_HEADER_MINSIZE; + stream.avail_in = static_cast(compressed_size - GZIP_HEADER_MINSIZE); stream.next_out = (unsigned char *)out_data; - stream.avail_out = out_size; + stream.avail_out = static_cast(out_size); mz_ret = mz_inflate(&stream, duckdb_miniz::MZ_FINISH); if (mz_ret != duckdb_miniz::MZ_OK && mz_ret != duckdb_miniz::MZ_STREAM_END) { @@ -54855,9 +55301,9 @@ struct MiniZStream { auto gzip_body = gzip_header + GZIP_HEADER_MINSIZE; stream.next_in = (const unsigned char*) uncompressed_data; - stream.avail_in = uncompressed_size; + stream.avail_in = static_cast(uncompressed_size); stream.next_out = gzip_body; - stream.avail_out = *out_size - GZIP_HEADER_MINSIZE; + stream.avail_out = static_cast(*out_size - GZIP_HEADER_MINSIZE); mz_ret = mz_deflate(&stream, duckdb_miniz::MZ_FINISH); if (mz_ret != duckdb_miniz::MZ_OK && mz_ret != duckdb_miniz::MZ_STREAM_END) { @@ -55100,9 +55546,9 @@ void MiniZStreamWrapper::Write(CompressedFile &file, StreamData &sd, data_ptr_t idx_t output_remaining = (sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_start; mz_stream_ptr->next_in = reinterpret_cast(uncompressed_data); - mz_stream_ptr->avail_in = remaining; + mz_stream_ptr->avail_in = NumericCast(remaining); mz_stream_ptr->next_out = sd.out_buff_start; - mz_stream_ptr->avail_out = output_remaining; + mz_stream_ptr->avail_out = NumericCast(output_remaining); auto res = mz_deflate(mz_stream_ptr.get(), duckdb_miniz::MZ_NO_FLUSH); if (res != duckdb_miniz::MZ_OK) { @@ -55128,7 +55574,7 @@ void MiniZStreamWrapper::FlushStream() { while (true) { auto output_remaining = (sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_start; mz_stream_ptr->next_out = sd.out_buff_start; - mz_stream_ptr->avail_out = output_remaining; + mz_stream_ptr->avail_out = NumericCast(output_remaining); auto res = mz_deflate(mz_stream_ptr.get(), duckdb_miniz::MZ_FINISH); sd.out_buff_start += (output_remaining - mz_stream_ptr->avail_out); @@ -55231,7 +55677,7 @@ string GZipFileSystem::UncompressGZIPString(const string &in) { auto bytes_remaining = in.size() - (body_ptr - in.data()); mz_stream_ptr->next_in = const_uchar_ptr_cast(body_ptr); - mz_stream_ptr->avail_in = bytes_remaining; + mz_stream_ptr->avail_in = NumericCast(bytes_remaining); unsigned char decompress_buffer[BUFSIZ]; string decompressed; @@ -55972,6 +56418,9 @@ class LocalFileSystem : public FileSystem { //! systems. static std::string GetLastErrorAsString(); + //! 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); + 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); @@ -56032,7 +56481,7 @@ extern "C" WINBASEAPI BOOL WINAPI GetPhysicallyInstalledSystemMemory(PULONGLONG) #include // NOLINT #endif // NOLINT #elif defined(_WIN32) -#include +#include #endif namespace duckdb { @@ -56041,6 +56490,9 @@ static void AssertValidFileFlags(uint8_t flags) { #ifdef DEBUG bool is_read = flags & FileFlags::FILE_FLAGS_READ; bool is_write = flags & FileFlags::FILE_FLAGS_WRITE; + bool is_create = (flags & FileFlags::FILE_FLAGS_FILE_CREATE) || (flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW); + bool is_private = (flags & FileFlags::FILE_FLAGS_PRIVATE); + // require either READ or WRITE (or both) D_ASSERT(is_read || is_write); // CREATE/Append flags require writing @@ -56049,6 +56501,9 @@ static void AssertValidFileFlags(uint8_t flags) { D_ASSERT(is_write || !(flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW)); // cannot combine CREATE and CREATE_NEW flags D_ASSERT(!(flags & FileFlags::FILE_FLAGS_FILE_CREATE && flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW)); + + // For is_private can only be set along with a create flag + D_ASSERT(!is_private || is_create); #endif } @@ -56171,6 +56626,8 @@ static string AdditionalProcessInfo(FileSystem &fs, pid_t pid) { } string process_name, process_owner; +// 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; if (proc_pidinfo(pid, PROC_PIDT_SHORTBSDINFO, 0, &proc, PROC_PIDT_SHORTBSDINFO_SIZE) == @@ -56182,6 +56639,9 @@ static string AdditionalProcessInfo(FileSystem &fs, pid_t pid) { process_owner = pw->pw_name; } } +#else + return string(); +#endif // try to get a better process name (full path) char full_exec_path[PROC_PIDPATHINFO_MAXSIZE]; if (proc_pidpath(pid, full_exec_path, PROC_PIDPATHINFO_MAXSIZE) > 0) { @@ -56245,6 +56705,25 @@ static string AdditionalProcessInfo(FileSystem &fs, pid_t pid) { } #endif +bool LocalFileSystem::IsPrivateFile(const string &path_p, FileOpener *opener) { + auto path = FileSystem::ExpandPath(path_p, opener); + + struct stat st; + + if (lstat(path.c_str(), &st) != 0) { + throw IOException( + "Failed to stat '%s' when checking file permissions, file may be missing or have incorrect permissions", + path.c_str()); + } + + // If group or other have any permission, the file is not private + if (st.st_mode & (S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH)) { + return false; + } + + return true; +} + unique_ptr LocalFileSystem::OpenFile(const string &path_p, uint8_t flags, FileLockType lock_type, FileCompressionType compression, FileOpener *opener) { auto path = FileSystem::ExpandPath(path_p, opener); @@ -56291,7 +56770,19 @@ unique_ptr LocalFileSystem::OpenFile(const string &path_p, uint8_t f open_flags |= O_DIRECT | O_SYNC; #endif } - int fd = open(path.c_str(), open_flags, 0666); + + // Determine permissions + mode_t filesec; + if (flags & FileFlags::FILE_FLAGS_PRIVATE) { + open_flags |= O_EXCL; // Ensure we error on existing files or the permissions may not set + filesec = 0600; + } else { + filesec = 0666; + } + + // Open the file + int fd = open(path.c_str(), open_flags, filesec); + if (fd == -1) { throw IOException("Cannot open file \"%s\": %s", {{"errno", std::to_string(errno)}}, path, strerror(errno)); } @@ -56381,6 +56872,7 @@ void LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, i } read_buffer += bytes_read; nr_bytes -= bytes_read; + location += bytes_read; } } @@ -56403,18 +56895,29 @@ void LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, throw IOException("Could not write file \"%s\": %s", {{"errno", std::to_string(errno)}}, handle.path, strerror(errno)); } - D_ASSERT(bytes_written >= 0 && bytes_written); + if (bytes_written == 0) { + throw IOException("Could not write to file \"%s\" - attempted to write 0 bytes: %s", + {{"errno", std::to_string(errno)}}, handle.path, strerror(errno)); + } write_buffer += bytes_written; nr_bytes -= bytes_written; + location += bytes_written; } } int64_t LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) { int fd = handle.Cast().fd; - int64_t bytes_written = write(fd, buffer, nr_bytes); - if (bytes_written == -1) { - throw IOException("Could not write file \"%s\": %s", {{"errno", std::to_string(errno)}}, handle.path, - strerror(errno)); + int64_t bytes_written = 0; + while (nr_bytes > 0) { + auto bytes_to_write = MinValue(idx_t(NumericLimits::Maximum()), idx_t(nr_bytes)); + int64_t current_bytes_written = write(fd, buffer, bytes_to_write); + if (current_bytes_written <= 0) { + throw IOException("Could not write file \"%s\": %s", {{"errno", std::to_string(errno)}}, handle.path, + strerror(errno)); + } + bytes_written += current_bytes_written; + buffer = (void *)(data_ptr_cast(buffer) + current_bytes_written); + nr_bytes -= current_bytes_written; } return bytes_written; } @@ -56690,6 +57193,11 @@ static string AdditionalLockInfo(const std::wstring path) { return conflict_string; } +bool LocalFileSystem::IsPrivateFile(const string &path_p, FileOpener *opener) { + // TODO: detect if file is shared in windows + return true; +} + unique_ptr LocalFileSystem::OpenFile(const string &path_p, uint8_t flags, FileLockType lock_type, FileCompressionType compression, FileOpener *opener) { auto path = FileSystem::ExpandPath(path_p, opener); @@ -56810,9 +57318,26 @@ static DWORD FSInternalWrite(FileHandle &handle, HANDLE hFile, void *buffer, int return bytes_written; } +static int64_t FSWrite(FileHandle &handle, HANDLE hFile, void *buffer, int64_t nr_bytes, idx_t location) { + int64_t bytes_written = 0; + while (nr_bytes > 0) { + auto bytes_to_write = MinValue(idx_t(NumericLimits::Maximum()), idx_t(nr_bytes)); + DWORD current_bytes_written = FSInternalWrite(handle, hFile, buffer, bytes_to_write, location); + if (current_bytes_written <= 0) { + throw IOException("Could not write file \"%s\": %s", {{"errno", std::to_string(errno)}}, handle.path, + strerror(errno)); + } + bytes_written += current_bytes_written; + buffer = (void *)(data_ptr_cast(buffer) + current_bytes_written); + location += current_bytes_written; + nr_bytes -= current_bytes_written; + } + return bytes_written; +} + void LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) { HANDLE hFile = handle.Cast().fd; - auto bytes_written = FSInternalWrite(handle, hFile, buffer, nr_bytes, location); + auto bytes_written = FSWrite(handle, hFile, buffer, nr_bytes, location); if (bytes_written != nr_bytes) { throw IOException("Could not write all bytes from file \"%s\": wanted=%lld wrote=%lld", handle.path, nr_bytes, bytes_written); @@ -56822,7 +57347,7 @@ void LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, int64_t LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) { HANDLE hFile = handle.Cast().fd; auto &pos = handle.Cast().position; - auto bytes_written = FSInternalWrite(handle, hFile, buffer, nr_bytes, pos); + auto bytes_written = FSWrite(handle, hFile, buffer, nr_bytes, pos); pos += bytes_written; return bytes_written; } @@ -58077,7 +58602,9 @@ DUCKDB_API string ConvertToString::Operation(string_t input); + namespace duckdb { +struct CastParameters; struct ValidityMask; class Vector; @@ -58090,15 +58617,17 @@ struct TryCast { struct TryCastErrorMessage { template - static inline bool Operation(SRC input, DST &result, string *error_message, bool strict = false) { - throw NotImplementedException("Unimplemented type for cast (%s -> %s)", GetTypeId(), GetTypeId()); + static inline bool Operation(SRC input, DST &result, CastParameters ¶meters) { + throw NotImplementedException(parameters.query_location, "Unimplemented type for cast (%s -> %s)", + GetTypeId(), GetTypeId()); } }; struct TryCastErrorMessageCommaSeparated { template - static inline bool Operation(SRC input, DST &result, string *error_message, bool strict = false) { - throw NotImplementedException("Unimplemented type for cast (%s -> %s)", GetTypeId(), GetTypeId()); + static inline bool Operation(SRC input, DST &result, CastParameters ¶meters) { + throw NotImplementedException(parameters.query_location, "Unimplemented type for cast (%s -> %s)", + GetTypeId(), GetTypeId()); } }; @@ -58129,9 +58658,11 @@ struct Cast { }; struct HandleCastError { - static void AssignError(const string &error_message, string *error_message_ptr) { + static void AssignError(const string &error_message, CastParameters ¶meters); + static void AssignError(const string &error_message, string *error_message_ptr, + optional_idx error_location = optional_idx()) { if (!error_message_ptr) { - throw ConversionException(error_message); + throw ConversionException(error_location, error_message); } if (error_message_ptr->empty()) { *error_message_ptr = error_message; @@ -58559,15 +59090,14 @@ DUCKDB_API bool TryCast::Operation(string_t input, float &result, bool strict); template <> DUCKDB_API bool TryCast::Operation(string_t input, double &result, bool strict); template <> -DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, float &result, string *error_message, bool strict); +DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, float &result, CastParameters ¶meters); template <> -DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, double &result, string *error_message, bool strict); +DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, double &result, CastParameters ¶meters); template <> -DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, string *error_message, - bool strict); +DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, CastParameters ¶meters); template <> -DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result, string *error_message, - bool strict); +DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result, + CastParameters ¶meters); //===--------------------------------------------------------------------===// // Date Casts @@ -58615,7 +59145,7 @@ DUCKDB_API bool TryCast::Operation(interval_t input, interval_t &result, bool st // String -> Date Casts //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, date_t &result, string *error_message, bool strict); +DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, date_t &result, CastParameters ¶meters); template <> DUCKDB_API bool TryCast::Operation(string_t input, date_t &result, bool strict); template <> @@ -58624,7 +59154,7 @@ date_t Cast::Operation(string_t input); // String -> Time Casts //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, string *error_message, bool strict); +DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, CastParameters ¶meters); template <> DUCKDB_API bool TryCast::Operation(string_t input, dtime_t &result, bool strict); template <> @@ -58633,7 +59163,7 @@ dtime_t Cast::Operation(string_t input); // String -> TimeTZ Casts //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, string *error_message, bool strict); +DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, CastParameters ¶meters); template <> DUCKDB_API bool TryCast::Operation(string_t input, dtime_tz_t &result, bool strict); template <> @@ -58642,7 +59172,7 @@ dtime_tz_t Cast::Operation(string_t input); // String -> Timestamp Casts //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, string *error_message, bool strict); +DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, CastParameters ¶meters); template <> DUCKDB_API bool TryCast::Operation(string_t input, timestamp_t &result, bool strict); template <> @@ -58651,7 +59181,7 @@ timestamp_t Cast::Operation(string_t input); // String -> Interval Casts //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, interval_t &result, string *error_message, bool strict); +DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, interval_t &result, CastParameters ¶meters); //===--------------------------------------------------------------------===// // string -> Non-Standard Timestamps @@ -58878,14 +59408,12 @@ string_t CastFromBlobToBit::Operation(string_t input, Vector &result); struct TryCastToBlob { template - static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message, - bool strict = false) { + static inline bool Operation(SRC input, DST &result, Vector &result_vector, CastParameters ¶meters) { throw InternalException("Unsupported type for try cast to blob"); } }; template <> -bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message, - bool strict); +bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters ¶meters); //===--------------------------------------------------------------------===// // Bits @@ -58901,24 +59429,25 @@ duckdb::string_t CastFromBitToString::Operation(duckdb::string_t input, Vector & struct CastFromBitToNumeric { template - static inline bool Operation(SRC input, DST &result, bool strict = false) { + static inline bool Operation(SRC input, DST &result, CastParameters ¶meters) { D_ASSERT(input.GetSize() > 1); // TODO: Allow conversion if the significant bytes of the bitstring can be cast to the target type // Currently only allows bitstring -> numeric if the full bitstring fits inside the numeric type if (input.GetSize() - 1 > sizeof(DST)) { - throw ConversionException("Bitstring doesn't fit inside of %s", GetTypeId()); + throw ConversionException(parameters.query_location, "Bitstring doesn't fit inside of %s", + GetTypeId()); } Bit::BitToNumeric(input, result); return (true); } }; template <> -bool CastFromBitToNumeric::Operation(string_t input, bool &result, bool strict); +bool CastFromBitToNumeric::Operation(string_t input, bool &result, CastParameters ¶meters); template <> -bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, bool strict); +bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, CastParameters ¶meters); template <> -bool CastFromBitToNumeric::Operation(string_t input, uhugeint_t &result, bool strict); +bool CastFromBitToNumeric::Operation(string_t input, uhugeint_t &result, CastParameters ¶meters); struct CastFromBitToBlob { template @@ -58930,15 +59459,13 @@ struct CastFromBitToBlob { struct TryCastToBit { template - static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message, - bool strict = false) { + static inline bool Operation(SRC input, DST &result, Vector &result_vector, CastParameters ¶meters) { throw InternalException("Unsupported type for try cast to bit"); } }; template <> -bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message, - bool strict); +bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters ¶meters); //===--------------------------------------------------------------------===// // UUID @@ -58954,15 +59481,14 @@ duckdb::string_t CastFromUUID::Operation(duckdb::hugeint_t input, Vector &vector struct TryCastToUUID { template - static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message, - bool strict = false) { + static inline bool Operation(SRC input, DST &result, Vector &result_vector, CastParameters ¶meters) { throw InternalException("Unsupported type for try cast to uuid"); } }; template <> DUCKDB_API bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector, - string *error_message, bool strict); + CastParameters ¶meters); //===--------------------------------------------------------------------===// // Pointers @@ -59689,21 +60215,21 @@ namespace duckdb { //===--------------------------------------------------------------------===// struct TryCastToDecimal { template - static inline bool Operation(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) { + static inline bool Operation(SRC input, DST &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { throw NotImplementedException("Unimplemented type for TryCastToDecimal!"); } }; struct TryCastToDecimalCommaSeparated { template - static inline bool Operation(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) { + static inline bool Operation(SRC input, DST &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { throw NotImplementedException("Unimplemented type for TryCastToDecimal!"); } }; struct TryCastFromDecimal { template - static inline bool Operation(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) { + static inline bool Operation(SRC input, DST &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { throw NotImplementedException("Unimplemented type for TryCastFromDecimal!"); } }; @@ -59712,379 +60238,405 @@ struct TryCastFromDecimal { // Cast Decimal <-> bool //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(bool input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(bool input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(bool input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(bool input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(bool input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(bool input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(bool input, hugeint_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(bool input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, bool &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int16_t input, bool &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, bool &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int32_t input, bool &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, bool &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int64_t input, bool &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, bool &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(hugeint_t input, bool &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> int8_t //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, hugeint_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int16_t input, int8_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int32_t input, int8_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int64_t input, int8_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, int8_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, int8_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> int16_t //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, hugeint_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int16_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int32_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int64_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, int16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> int32_t //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, hugeint_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int16_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int32_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int64_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, int32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> int64_t //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, hugeint_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int16_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int32_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int64_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, int64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> hugeint_t //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, hugeint_t &result, string *error_message, uint8_t width, - uint8_t scale); +DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, hugeint_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> uhugeint_t //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int16_t &result, string *error_message, uint8_t width, - uint8_t scale); +DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int16_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int32_t &result, string *error_message, uint8_t width, - uint8_t scale); +DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int32_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int64_t &result, string *error_message, uint8_t width, - uint8_t scale); +DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int64_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, hugeint_t &result, string *error_message, uint8_t width, - uint8_t scale); +DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, hugeint_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, uhugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, uhugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, uhugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, uhugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, uhugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, uhugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, uhugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, uhugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> uint8_t //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, hugeint_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, uint8_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int16_t input, uint8_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, uint8_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int32_t input, uint8_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, uint8_t &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int64_t input, uint8_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, uint8_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, uint8_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> uint16_t //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, hugeint_t &result, string *error_message, uint8_t width, - uint8_t scale); +DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, hugeint_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, uint16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, uint16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, uint16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, uint16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, uint16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, uint16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, uint16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, uint16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> uint32_t //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, hugeint_t &result, string *error_message, uint8_t width, - uint8_t scale); +DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, hugeint_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, uint32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, uint32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, uint32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, uint32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, uint32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, uint32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, uint32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, uint32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> uint64_t //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, hugeint_t &result, string *error_message, uint8_t width, - uint8_t scale); +DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, hugeint_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, uint64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, uint64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, uint64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, uint64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, uint64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, uint64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, uint64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, uint64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> float //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(float input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(float input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(float input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(float input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(float input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(float input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(float input, hugeint_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(float input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, float &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int16_t input, float &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, float &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int32_t input, float &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, float &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int64_t input, float &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, float &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(hugeint_t input, float &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> double //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(double input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(double input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(double input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(double input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(double input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(double input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(double input, hugeint_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(double input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int16_t input, double &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int16_t input, double &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int32_t input, double &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int32_t input, double &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(int64_t input, double &result, string *error_message, uint8_t width, uint8_t scale); +bool TryCastFromDecimal::Operation(int64_t input, double &result, CastParameters ¶meters, uint8_t width, + uint8_t scale); template <> -bool TryCastFromDecimal::Operation(hugeint_t input, double &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, double &result, CastParameters ¶meters, uint8_t width, uint8_t scale); //===--------------------------------------------------------------------===// // Cast Decimal <-> VARCHAR //===--------------------------------------------------------------------===// template <> -DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int16_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int32_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int64_t &result, string *error_message, uint8_t width, +DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, string *error_message, uint8_t width, - uint8_t scale); +DUCKDB_API bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int16_t &result, string *error_message, +DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int32_t &result, string *error_message, +DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int64_t &result, string *error_message, +DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); template <> -DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, hugeint_t &result, string *error_message, +DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale); struct StringCastFromDecimal { @@ -62896,12 +63448,12 @@ struct IntegerCastOperation { if (DUCKDB_UNLIKELY(state.result < (NumericLimits::Minimum() + digit) / 10)) { return false; } - state.result = state.result * 10 - digit; + state.result = UnsafeNumericCast(state.result * 10 - digit); } else { if (DUCKDB_UNLIKELY(state.result > (NumericLimits::Maximum() - digit) / 10)) { return false; } - state.result = state.result * 10 + digit; + state.result = UnsafeNumericCast(state.result * 10 + digit); } return true; } @@ -62912,7 +63464,7 @@ struct IntegerCastOperation { if (DUCKDB_UNLIKELY(state.result > (NumericLimits::Maximum() - digit) / 16)) { return false; } - state.result = state.result * 16 + digit; + state.result = UnsafeNumericCast(state.result * 16 + digit); return true; } @@ -62922,7 +63474,7 @@ struct IntegerCastOperation { if (DUCKDB_UNLIKELY(state.result > (NumericLimits::Maximum() - digit) / 2)) { return false; } - state.result = state.result * 2 + digit; + state.result = UnsafeNumericCast(state.result * 2 + digit); return true; } @@ -62993,7 +63545,7 @@ struct IntegerDecimalCastOperation : IntegerCastOperation { } // Handle decimals - e = exponent - state.decimal_digits; + e = UnsafeNumericCast(exponent - state.decimal_digits); store_t remainder = 0; if (e < 0) { if (static_cast(-e) <= NumericLimits::Digits()) { @@ -64279,7 +64831,7 @@ bool TryCast::Operation(string_t input, bool &result, bool strict) { switch (input_size) { case 1: { - char c = std::tolower(*input_data); + char c = UnsafeNumericCast(std::tolower(*input_data)); if (c == 't' || (!strict && c == '1')) { result = true; return true; @@ -64290,10 +64842,10 @@ bool TryCast::Operation(string_t input, bool &result, bool strict) { return false; } case 4: { - char t = std::tolower(input_data[0]); - char r = std::tolower(input_data[1]); - char u = std::tolower(input_data[2]); - char e = std::tolower(input_data[3]); + char t = UnsafeNumericCast(std::tolower(input_data[0])); + char r = UnsafeNumericCast(std::tolower(input_data[1])); + char u = UnsafeNumericCast(std::tolower(input_data[2])); + char e = UnsafeNumericCast(std::tolower(input_data[3])); if (t == 't' && r == 'r' && u == 'u' && e == 'e') { result = true; return true; @@ -64301,11 +64853,11 @@ bool TryCast::Operation(string_t input, bool &result, bool strict) { return false; } case 5: { - char f = std::tolower(input_data[0]); - char a = std::tolower(input_data[1]); - char l = std::tolower(input_data[2]); - char s = std::tolower(input_data[3]); - char e = std::tolower(input_data[4]); + char f = UnsafeNumericCast(std::tolower(input_data[0])); + char a = UnsafeNumericCast(std::tolower(input_data[1])); + char l = UnsafeNumericCast(std::tolower(input_data[2])); + char s = UnsafeNumericCast(std::tolower(input_data[3])); + char e = UnsafeNumericCast(std::tolower(input_data[4])); if (f == 'f' && a == 'a' && l == 'l' && s == 's' && e == 'e') { result = false; return true; @@ -64361,20 +64913,20 @@ bool TryCast::Operation(string_t input, double &result, bool strict) { } template <> -bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, string *error_message, bool strict) { - if (!TryDoubleCast(input.GetData(), input.GetSize(), result, strict, ',')) { +bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, CastParameters ¶meters) { + if (!TryDoubleCast(input.GetData(), input.GetSize(), result, parameters.strict, ',')) { HandleCastError::AssignError(StringUtil::Format("Could not cast string to float: \"%s\"", input.GetString()), - error_message); + parameters); return false; } return true; } template <> -bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result, string *error_message, bool strict) { - if (!TryDoubleCast(input.GetData(), input.GetSize(), result, strict, ',')) { +bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result, CastParameters ¶meters) { + if (!TryDoubleCast(input.GetData(), input.GetSize(), result, parameters.strict, ',')) { HandleCastError::AssignError(StringUtil::Format("Could not cast string to double: \"%s\"", input.GetString()), - error_message); + parameters); return false; } return true; @@ -64478,37 +65030,49 @@ bool TryCast::Operation(interval_t input, interval_t &result, bool strict) { //===--------------------------------------------------------------------===// template <> duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_t input, Vector &result) { - return StringCast::Operation(Timestamp::FromEpochNanoSeconds(input.value), result); + return StringCast::Operation(CastTimestampNsToUs::Operation(input), result); } template <> duckdb::string_t CastFromTimestampMS::Operation(duckdb::timestamp_t input, Vector &result) { - return StringCast::Operation(Timestamp::FromEpochMs(input.value), result); + return StringCast::Operation(CastTimestampMsToUs::Operation(input), result); } template <> duckdb::string_t CastFromTimestampSec::Operation(duckdb::timestamp_t input, Vector &result) { - return StringCast::Operation(Timestamp::FromEpochSeconds(input.value), result); + return StringCast::Operation(CastTimestampSecToUs::Operation(input), result); } template <> timestamp_t CastTimestampUsToMs::Operation(timestamp_t input) { + if (!Timestamp::IsFinite(input)) { + return input; + } timestamp_t cast_timestamp(Timestamp::GetEpochMs(input)); return cast_timestamp; } template <> timestamp_t CastTimestampUsToNs::Operation(timestamp_t input) { + if (!Timestamp::IsFinite(input)) { + return input; + } timestamp_t cast_timestamp(Timestamp::GetEpochNanoSeconds(input)); return cast_timestamp; } template <> timestamp_t CastTimestampUsToSec::Operation(timestamp_t input) { + if (!Timestamp::IsFinite(input)) { + return input; + } timestamp_t cast_timestamp(Timestamp::GetEpochSeconds(input)); return cast_timestamp; } template <> timestamp_t CastTimestampMsToUs::Operation(timestamp_t input) { + if (!Timestamp::IsFinite(input)) { + return input; + } return Timestamp::FromEpochMs(input.value); } @@ -64524,17 +65088,36 @@ dtime_t CastTimestampMsToTime::Operation(timestamp_t input) { template <> timestamp_t CastTimestampMsToNs::Operation(timestamp_t input) { + if (!Timestamp::IsFinite(input)) { + return input; + } auto us = CastTimestampMsToUs::Operation(input); return CastTimestampUsToNs::Operation(us); } template <> timestamp_t CastTimestampNsToUs::Operation(timestamp_t input) { + if (!Timestamp::IsFinite(input)) { + return input; + } return Timestamp::FromEpochNanoSeconds(input.value); } +template <> +timestamp_t CastTimestampSecToUs::Operation(timestamp_t input) { + if (!Timestamp::IsFinite(input)) { + return input; + } + return Timestamp::FromEpochSeconds(input.value); +} + template <> date_t CastTimestampNsToDate::Operation(timestamp_t input) { + if (input == timestamp_t::infinity()) { + return date_t::infinity(); + } else if (input == timestamp_t::ninfinity()) { + return date_t::ninfinity(); + } const auto us = CastTimestampNsToUs::Operation(input); return Timestamp::GetDate(us); } @@ -64547,17 +65130,18 @@ dtime_t CastTimestampNsToTime::Operation(timestamp_t input) { template <> timestamp_t CastTimestampSecToMs::Operation(timestamp_t input) { + if (!Timestamp::IsFinite(input)) { + return input; + } auto us = CastTimestampSecToUs::Operation(input); return CastTimestampUsToMs::Operation(us); } -template <> -timestamp_t CastTimestampSecToUs::Operation(timestamp_t input) { - return Timestamp::FromEpochSeconds(input.value); -} - template <> timestamp_t CastTimestampSecToNs::Operation(timestamp_t input) { + if (!Timestamp::IsFinite(input)) { + return input; + } auto us = CastTimestampSecToUs::Operation(input); return CastTimestampUsToNs::Operation(us); } @@ -64582,7 +65166,15 @@ bool TryCastToTimestampNS::Operation(string_t input, timestamp_t &result, bool s if (!TryCast::Operation(input, result, strict)) { return false; } - result = Timestamp::GetEpochNanoSeconds(result); + if (!Timestamp::IsFinite(result)) { + return true; + } + + int64_t nanoseconds; + if (!Timestamp::TryGetEpochNanoSeconds(result, nanoseconds)) { + throw ConversionException("Could not convert VARCHAR value '%s' to Timestamp(NS)", input.GetString()); + } + result = nanoseconds; return true; } @@ -64591,6 +65183,9 @@ bool TryCastToTimestampMS::Operation(string_t input, timestamp_t &result, bool s if (!TryCast::Operation(input, result, strict)) { return false; } + if (!Timestamp::IsFinite(result)) { + return true; + } result = Timestamp::GetEpochMs(result); return true; } @@ -64600,6 +65195,9 @@ bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool if (!TryCast::Operation(input, result, strict)) { return false; } + if (!Timestamp::IsFinite(result)) { + return true; + } result = Timestamp::GetEpochSeconds(result); return true; } @@ -64609,6 +65207,9 @@ bool TryCastToTimestampNS::Operation(date_t input, timestamp_t &result, bool str if (!TryCast::Operation(input, result, strict)) { return false; } + if (!Timestamp::IsFinite(result)) { + return true; + } if (!TryMultiplyOperator::Operation(result.value, Interval::NANOS_PER_MICRO, result.value)) { return false; } @@ -64620,6 +65221,9 @@ bool TryCastToTimestampMS::Operation(date_t input, timestamp_t &result, bool str if (!TryCast::Operation(input, result, strict)) { return false; } + if (!Timestamp::IsFinite(result)) { + return true; + } result.value /= Interval::MICROS_PER_MSEC; return true; } @@ -64629,6 +65233,9 @@ bool TryCastToTimestampSec::Operation(date_t input, timestamp_t &result, bool st if (!TryCast::Operation(input, result, strict)) { return false; } + if (!Timestamp::IsFinite(result)) { + return true; + } result.value /= Interval::MICROS_PER_MSEC * Interval::MSECS_PER_SEC; return true; } @@ -64683,10 +65290,9 @@ string_t CastFromPointer::Operation(uintptr_t input, Vector &vector) { // Cast To Blob //===--------------------------------------------------------------------===// template <> -bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message, - bool strict) { +bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters ¶meters) { idx_t result_size; - if (!Blob::TryGetBlobSize(input, result_size, error_message)) { + if (!Blob::TryGetBlobSize(input, result_size, parameters)) { return false; } @@ -64700,10 +65306,9 @@ bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_v // Cast To Bit //===--------------------------------------------------------------------===// template <> -bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message, - bool strict) { +bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters ¶meters) { idx_t result_size; - if (!Bit::TryGetBitStringSize(input, result_size, error_message)) { + if (!Bit::TryGetBitStringSize(input, result_size, parameters.error_message)) { return false; } @@ -64714,32 +65319,34 @@ bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_ve } template <> -bool CastFromBitToNumeric::Operation(string_t input, bool &result, bool strict) { +bool CastFromBitToNumeric::Operation(string_t input, bool &result, CastParameters ¶meters) { D_ASSERT(input.GetSize() > 1); uint8_t value; - bool success = CastFromBitToNumeric::Operation(input, value, strict); + bool success = CastFromBitToNumeric::Operation(input, value, parameters); result = (value > 0); return (success); } template <> -bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, bool strict) { +bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, CastParameters ¶meters) { D_ASSERT(input.GetSize() > 1); if (input.GetSize() - 1 > sizeof(hugeint_t)) { - throw ConversionException("Bitstring doesn't fit inside of %s", GetTypeId()); + throw ConversionException(parameters.query_location, "Bitstring doesn't fit inside of %s", + GetTypeId()); } Bit::BitToNumeric(input, result); return (true); } template <> -bool CastFromBitToNumeric::Operation(string_t input, uhugeint_t &result, bool strict) { +bool CastFromBitToNumeric::Operation(string_t input, uhugeint_t &result, CastParameters ¶meters) { D_ASSERT(input.GetSize() > 1); if (input.GetSize() - 1 > sizeof(uhugeint_t)) { - throw ConversionException("Bitstring doesn't fit inside of %s", GetTypeId()); + throw ConversionException(parameters.query_location, "Bitstring doesn't fit inside of %s", + GetTypeId()); } Bit::BitToNumeric(input, result); return (true); @@ -64760,8 +65367,7 @@ string_t CastFromUUID::Operation(hugeint_t input, Vector &vector) { // Cast To UUID //===--------------------------------------------------------------------===// template <> -bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector, string *error_message, - bool strict) { +bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector, CastParameters ¶meters) { return UUID::FromString(input.GetString(), result); } @@ -64769,9 +65375,9 @@ bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_ // Cast To Date //===--------------------------------------------------------------------===// template <> -bool TryCastErrorMessage::Operation(string_t input, date_t &result, string *error_message, bool strict) { - if (!TryCast::Operation(input, result, strict)) { - HandleCastError::AssignError(Date::ConversionError(input), error_message); +bool TryCastErrorMessage::Operation(string_t input, date_t &result, CastParameters ¶meters) { + if (!TryCast::Operation(input, result, parameters.strict)) { + HandleCastError::AssignError(Date::ConversionError(input), parameters); return false; } return true; @@ -64793,9 +65399,9 @@ date_t Cast::Operation(string_t input) { // Cast To Time //===--------------------------------------------------------------------===// template <> -bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, string *error_message, bool strict) { - if (!TryCast::Operation(input, result, strict)) { - HandleCastError::AssignError(Time::ConversionError(input), error_message); +bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, CastParameters ¶meters) { + if (!TryCast::Operation(input, result, parameters.strict)) { + HandleCastError::AssignError(Time::ConversionError(input), parameters); return false; } return true; @@ -64816,9 +65422,9 @@ dtime_t Cast::Operation(string_t input) { // Cast To TimeTZ //===--------------------------------------------------------------------===// template <> -bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, string *error_message, bool strict) { - if (!TryCast::Operation(input, result, strict)) { - HandleCastError::AssignError(Time::ConversionError(input), error_message); +bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, CastParameters ¶meters) { + if (!TryCast::Operation(input, result, parameters.strict)) { + HandleCastError::AssignError(Time::ConversionError(input), parameters); return false; } return true; @@ -64827,7 +65433,8 @@ bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, string * template <> bool TryCast::Operation(string_t input, dtime_tz_t &result, bool strict) { idx_t pos; - return Time::TryConvertTimeTZ(input.GetData(), input.GetSize(), pos, result, strict); + bool has_offset; + return Time::TryConvertTimeTZ(input.GetData(), input.GetSize(), pos, result, has_offset, strict); } template <> @@ -64843,15 +65450,15 @@ dtime_tz_t Cast::Operation(string_t input) { // Cast To Timestamp //===--------------------------------------------------------------------===// template <> -bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, string *error_message, bool strict) { +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) { return true; } if (cast_result == TimestampCastResult::ERROR_INCORRECT_FORMAT) { - HandleCastError::AssignError(Timestamp::ConversionError(input), error_message); + HandleCastError::AssignError(Timestamp::ConversionError(input), parameters); } else { - HandleCastError::AssignError(Timestamp::UnsupportedTimezoneError(input), error_message); + HandleCastError::AssignError(Timestamp::UnsupportedTimezoneError(input), parameters); } return false; } @@ -64870,8 +65477,8 @@ timestamp_t Cast::Operation(string_t input) { // Cast From Interval //===--------------------------------------------------------------------===// template <> -bool TryCastErrorMessage::Operation(string_t input, interval_t &result, string *error_message, bool strict) { - return Interval::FromCString(input.GetData(), input.GetSize(), result, error_message, strict); +bool TryCastErrorMessage::Operation(string_t input, interval_t &result, CastParameters ¶meters) { + return Interval::FromCString(input.GetData(), input.GetSize(), result, parameters.error_message, parameters.strict); } //===--------------------------------------------------------------------===// @@ -64994,7 +65601,7 @@ struct HugeIntegerCastOperation { remainder *= -1; } state.decimal = remainder; - state.decimal_total_digits = -e; + state.decimal_total_digits = UnsafeNumericCast(-e); state.decimal_intermediate = 0; state.decimal_intermediate_digits = 0; return Finalize(state); @@ -65178,7 +65785,7 @@ struct DecimalCastOperation { // Everything beyond that amount needs to be truncated if (decimal_excess > exponent) { // We've allowed too many decimals - state.excessive_decimals = decimal_excess - exponent; + state.excessive_decimals = UnsafeNumericCast(decimal_excess - exponent); exponent = 0; } else { exponent -= decimal_excess; @@ -65283,7 +65890,7 @@ struct DecimalCastOperation { }; template -bool TryDecimalStringCast(string_t input, T &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryDecimalStringCast(string_t input, T &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { DecimalCastData state; state.result = 0; state.width = width; @@ -65298,7 +65905,7 @@ bool TryDecimalStringCast(string_t input, T &result, string *error_message, uint input.GetData(), input.GetSize(), state, false)) { string error = StringUtil::Format("Could not convert string \"%s\" to DECIMAL(%d,%d)", input.GetString(), (int)width, (int)scale); - HandleCastError::AssignError(error, error_message); + HandleCastError::AssignError(error, parameters); return false; } result = state.result; @@ -65306,48 +65913,51 @@ bool TryDecimalStringCast(string_t input, T &result, string *error_message, uint } template <> -bool TryCastToDecimal::Operation(string_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return TryDecimalStringCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(string_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return TryDecimalStringCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(string_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return TryDecimalStringCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(string_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return TryDecimalStringCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(string_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return TryDecimalStringCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(string_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return TryDecimalStringCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryDecimalStringCast(input, result, error_message, width, scale); + return TryDecimalStringCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimalCommaSeparated::Operation(string_t input, int16_t &result, string *error_message, uint8_t width, - uint8_t scale) { - return TryDecimalStringCast(input, result, error_message, width, scale); +bool TryCastToDecimalCommaSeparated::Operation(string_t input, int16_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale) { + return TryDecimalStringCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimalCommaSeparated::Operation(string_t input, int32_t &result, string *error_message, uint8_t width, - uint8_t scale) { - return TryDecimalStringCast(input, result, error_message, width, scale); +bool TryCastToDecimalCommaSeparated::Operation(string_t input, int32_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale) { + return TryDecimalStringCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimalCommaSeparated::Operation(string_t input, int64_t &result, string *error_message, uint8_t width, - uint8_t scale) { - return TryDecimalStringCast(input, result, error_message, width, scale); +bool TryCastToDecimalCommaSeparated::Operation(string_t input, int64_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale) { + return TryDecimalStringCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimalCommaSeparated::Operation(string_t input, hugeint_t &result, string *error_message, uint8_t width, - uint8_t scale) { - return TryDecimalStringCast(input, result, error_message, width, scale); +bool TryCastToDecimalCommaSeparated::Operation(string_t input, hugeint_t &result, CastParameters ¶meters, + uint8_t width, uint8_t scale) { + return TryDecimalStringCast(input, result, parameters, width, scale); } template <> @@ -65376,9 +65986,9 @@ string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_ // Decimal <-> Bool //===--------------------------------------------------------------------===// template -bool TryCastBoolToDecimal(bool input, T &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryCastBoolToDecimal(bool input, T &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { if (width > scale) { - result = input ? OP::POWERS_OF_TEN[scale] : 0; + result = UnsafeNumericCast(input ? OP::POWERS_OF_TEN[scale] : 0); return true; } else { return TryCast::Operation(input, result); @@ -65386,42 +65996,50 @@ bool TryCastBoolToDecimal(bool input, T &result, string *error_message, uint8_t } template <> -bool TryCastToDecimal::Operation(bool input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return TryCastBoolToDecimal(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(bool input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return TryCastBoolToDecimal(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(bool input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return TryCastBoolToDecimal(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(bool input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return TryCastBoolToDecimal(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(bool input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return TryCastBoolToDecimal(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(bool input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return TryCastBoolToDecimal(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(bool input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) { - return TryCastBoolToDecimal(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(bool input, hugeint_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return TryCastBoolToDecimal(input, result, parameters, width, scale); } template <> -bool TryCastFromDecimal::Operation(int16_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryCastFromDecimal::Operation(int16_t input, bool &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { return TryCast::Operation(input, result); } template <> -bool TryCastFromDecimal::Operation(int32_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryCastFromDecimal::Operation(int32_t input, bool &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { return TryCast::Operation(input, result); } template <> -bool TryCastFromDecimal::Operation(int64_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryCastFromDecimal::Operation(int64_t input, bool &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { return TryCast::Operation(input, result); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryCastFromDecimal::Operation(hugeint_t input, bool &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { return TryCast::Operation(input, result); } @@ -65443,26 +66061,26 @@ struct UnsignedToDecimalOperator { }; template -bool StandardNumericToDecimalCast(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) { +bool StandardNumericToDecimalCast(SRC input, DST &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { // check for overflow - DST max_width = NumericHelper::POWERS_OF_TEN[width - scale]; + DST max_width = UnsafeNumericCast(NumericHelper::POWERS_OF_TEN[width - scale]); if (OP::template Operation(input, max_width)) { string error = StringUtil::Format("Could not cast value %d to DECIMAL(%d,%d)", input, width, scale); - HandleCastError::AssignError(error, error_message); + HandleCastError::AssignError(error, parameters); return false; } - result = DST(input) * NumericHelper::POWERS_OF_TEN[scale]; + result = UnsafeNumericCast(DST(input) * NumericHelper::POWERS_OF_TEN[scale]); return true; } template -bool NumericToHugeDecimalCast(SRC input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) { +bool NumericToHugeDecimalCast(SRC input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { // check for overflow hugeint_t max_width = Hugeint::POWERS_OF_TEN[width - scale]; hugeint_t hinput = Hugeint::Convert(input); if (hinput >= max_width || hinput <= -max_width) { string error = StringUtil::Format("Could not cast value %s to DECIMAL(%d,%d)", hinput.ToString(), width, scale); - HandleCastError::AssignError(error, error_message); + HandleCastError::AssignError(error, parameters); return false; } result = hinput * Hugeint::POWERS_OF_TEN[scale]; @@ -65473,191 +66091,216 @@ bool NumericToHugeDecimalCast(SRC input, hugeint_t &result, string *error_messag // Cast int8_t -> Decimal //===--------------------------------------------------------------------===// template <> -bool TryCastToDecimal::Operation(int8_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int8_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int8_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int8_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int8_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int8_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int8_t input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) { - return NumericToHugeDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int8_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return NumericToHugeDecimalCast(input, result, parameters, width, scale); } //===--------------------------------------------------------------------===// // Cast int16_t -> Decimal //===--------------------------------------------------------------------===// template <> -bool TryCastToDecimal::Operation(int16_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int16_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int16_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int16_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int16_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int16_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int16_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(int16_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return NumericToHugeDecimalCast(input, result, error_message, width, scale); + return NumericToHugeDecimalCast(input, result, parameters, width, scale); } //===--------------------------------------------------------------------===// // Cast int32_t -> Decimal //===--------------------------------------------------------------------===// template <> -bool TryCastToDecimal::Operation(int32_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int32_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int32_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int32_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int32_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int32_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int32_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(int32_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return NumericToHugeDecimalCast(input, result, error_message, width, scale); + return NumericToHugeDecimalCast(input, result, parameters, width, scale); } //===--------------------------------------------------------------------===// // Cast int64_t -> Decimal //===--------------------------------------------------------------------===// template <> -bool TryCastToDecimal::Operation(int64_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int64_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int64_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int64_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int64_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(int64_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(int64_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(int64_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return NumericToHugeDecimalCast(input, result, error_message, width, scale); + return NumericToHugeDecimalCast(input, result, parameters, width, scale); } //===--------------------------------------------------------------------===// // Cast uint8_t -> Decimal //===--------------------------------------------------------------------===// template <> -bool TryCastToDecimal::Operation(uint8_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint8_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint8_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint8_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint8_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint8_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint8_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(uint8_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return NumericToHugeDecimalCast(input, result, error_message, width, scale); + return NumericToHugeDecimalCast(input, result, parameters, width, scale); } //===--------------------------------------------------------------------===// // Cast uint16_t -> Decimal //===--------------------------------------------------------------------===// template <> -bool TryCastToDecimal::Operation(uint16_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint16_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint16_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint16_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint16_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint16_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint16_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(uint16_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return NumericToHugeDecimalCast(input, result, error_message, width, scale); + return NumericToHugeDecimalCast(input, result, parameters, width, scale); } //===--------------------------------------------------------------------===// // Cast uint32_t -> Decimal //===--------------------------------------------------------------------===// template <> -bool TryCastToDecimal::Operation(uint32_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint32_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint32_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint32_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint32_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint32_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint32_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(uint32_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return NumericToHugeDecimalCast(input, result, error_message, width, scale); + return NumericToHugeDecimalCast(input, result, parameters, width, scale); } //===--------------------------------------------------------------------===// // Cast uint64_t -> Decimal //===--------------------------------------------------------------------===// template <> -bool TryCastToDecimal::Operation(uint64_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint64_t input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint64_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint64_t input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint64_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return StandardNumericToDecimalCast(input, result, error_message, - width, scale); +bool TryCastToDecimal::Operation(uint64_t input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return StandardNumericToDecimalCast(input, result, parameters, width, + scale); } template <> -bool TryCastToDecimal::Operation(uint64_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(uint64_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return NumericToHugeDecimalCast(input, result, error_message, width, scale); + return NumericToHugeDecimalCast(input, result, parameters, width, scale); } //===--------------------------------------------------------------------===// // Hugeint -> Decimal Cast //===--------------------------------------------------------------------===// template -bool HugeintToDecimalCast(hugeint_t input, DST &result, string *error_message, uint8_t width, uint8_t scale) { +bool HugeintToDecimalCast(hugeint_t input, DST &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { // check for overflow hugeint_t max_width = Hugeint::POWERS_OF_TEN[width - scale]; if (input >= max_width || input <= -max_width) { string error = StringUtil::Format("Could not cast value %s to DECIMAL(%d,%d)", input.ToString(), width, scale); - HandleCastError::AssignError(error, error_message); + HandleCastError::AssignError(error, parameters); return false; } result = Hugeint::Cast(input * Hugeint::POWERS_OF_TEN[scale]); @@ -65665,39 +66308,39 @@ bool HugeintToDecimalCast(hugeint_t input, DST &result, string *error_message, u } template <> -bool TryCastToDecimal::Operation(hugeint_t input, int16_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(hugeint_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return HugeintToDecimalCast(input, result, error_message, width, scale); + return HugeintToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(hugeint_t input, int32_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(hugeint_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return HugeintToDecimalCast(input, result, error_message, width, scale); + return HugeintToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(hugeint_t input, int64_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(hugeint_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return HugeintToDecimalCast(input, result, error_message, width, scale); + return HugeintToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(hugeint_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(hugeint_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return HugeintToDecimalCast(input, result, error_message, width, scale); + return HugeintToDecimalCast(input, result, parameters, width, scale); } //===--------------------------------------------------------------------===// // Uhugeint -> Decimal Cast //===--------------------------------------------------------------------===// template -bool UhugeintToDecimalCast(uhugeint_t input, DST &result, string *error_message, uint8_t width, uint8_t scale) { +bool UhugeintToDecimalCast(uhugeint_t input, DST &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { // check for overflow uhugeint_t max_width = Uhugeint::POWERS_OF_TEN[width - scale]; if (input >= max_width) { string error = StringUtil::Format("Could not cast value %s to DECIMAL(%d,%d)", input.ToString(), width, scale); - HandleCastError::AssignError(error, error_message); + HandleCastError::AssignError(error, parameters); return false; } result = Uhugeint::Cast(input * Uhugeint::POWERS_OF_TEN[scale]); @@ -65705,41 +66348,41 @@ bool UhugeintToDecimalCast(uhugeint_t input, DST &result, string *error_message, } template <> -bool TryCastToDecimal::Operation(uhugeint_t input, int16_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(uhugeint_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return UhugeintToDecimalCast(input, result, error_message, width, scale); + return UhugeintToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(uhugeint_t input, int32_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(uhugeint_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return UhugeintToDecimalCast(input, result, error_message, width, scale); + return UhugeintToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(uhugeint_t input, int64_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(uhugeint_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return UhugeintToDecimalCast(input, result, error_message, width, scale); + return UhugeintToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(uhugeint_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastToDecimal::Operation(uhugeint_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return UhugeintToDecimalCast(input, result, error_message, width, scale); + return UhugeintToDecimalCast(input, result, parameters, width, scale); } //===--------------------------------------------------------------------===// // Float/Double -> Decimal Cast //===--------------------------------------------------------------------===// template -bool DoubleToDecimalCast(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) { +bool DoubleToDecimalCast(SRC input, DST &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { double value = input * NumericHelper::DOUBLE_POWERS_OF_TEN[scale]; // Add the sign (-1, 0, 1) times a tiny value to fix floating point issues (issue 3091) double sign = (double(0) < value) - (value < double(0)); value += 1e-9 * sign; if (value <= -NumericHelper::DOUBLE_POWERS_OF_TEN[width] || value >= NumericHelper::DOUBLE_POWERS_OF_TEN[width]) { string error = StringUtil::Format("Could not cast value %f to DECIMAL(%d,%d)", value, width, scale); - HandleCastError::AssignError(error, error_message); + HandleCastError::AssignError(error, parameters); return false; } result = Cast::Operation(value); @@ -65747,73 +66390,81 @@ bool DoubleToDecimalCast(SRC input, DST &result, string *error_message, uint8_t } template <> -bool TryCastToDecimal::Operation(float input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return DoubleToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(float input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return DoubleToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(float input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return DoubleToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(float input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return DoubleToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(float input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return DoubleToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(float input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return DoubleToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(float input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) { - return DoubleToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(float input, hugeint_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return DoubleToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(double input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) { - return DoubleToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(double input, int16_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return DoubleToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(double input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) { - return DoubleToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(double input, int32_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return DoubleToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(double input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) { - return DoubleToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(double input, int64_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return DoubleToDecimalCast(input, result, parameters, width, scale); } template <> -bool TryCastToDecimal::Operation(double input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) { - return DoubleToDecimalCast(input, result, error_message, width, scale); +bool TryCastToDecimal::Operation(double input, hugeint_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return DoubleToDecimalCast(input, result, parameters, width, scale); } //===--------------------------------------------------------------------===// // Decimal -> Numeric Cast //===--------------------------------------------------------------------===// template -bool TryCastDecimalToNumeric(SRC input, DST &result, string *error_message, uint8_t scale) { +bool TryCastDecimalToNumeric(SRC input, DST &result, CastParameters ¶meters, uint8_t scale) { // Round away from 0. const auto power = NumericHelper::POWERS_OF_TEN[scale]; // https://graphics.stanford.edu/~seander/bithacks.html#ConditionalNegate const auto fNegate = int64_t(input < 0); const auto rounding = ((power ^ -fNegate) + fNegate) / 2; const auto scaled_value = (input + rounding) / power; - if (!TryCast::Operation(scaled_value, result)) { + if (!TryCast::Operation(UnsafeNumericCast(scaled_value), result)) { string error = StringUtil::Format("Failed to cast decimal value %d to type %s", scaled_value, GetTypeId()); - HandleCastError::AssignError(error, error_message); + HandleCastError::AssignError(error, parameters); return false; } return true; } template -bool TryCastHugeDecimalToNumeric(hugeint_t input, DST &result, string *error_message, uint8_t scale) { +bool TryCastHugeDecimalToNumeric(hugeint_t input, DST &result, CastParameters ¶meters, uint8_t scale) { const auto power = Hugeint::POWERS_OF_TEN[scale]; const auto rounding = ((input < 0) ? -power : power) / 2; auto scaled_value = (input + rounding) / power; if (!TryCast::Operation(scaled_value, result)) { string error = StringUtil::Format("Failed to cast decimal value %s to type %s", ConvertToString::Operation(scaled_value), GetTypeId()); - HandleCastError::AssignError(error, error_message); + HandleCastError::AssignError(error, parameters); return false; } return true; @@ -65823,237 +66474,240 @@ bool TryCastHugeDecimalToNumeric(hugeint_t input, DST &result, string *error_mes // Cast Decimal -> int8_t //===--------------------------------------------------------------------===// template <> -bool TryCastFromDecimal::Operation(int16_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); +bool TryCastFromDecimal::Operation(int16_t input, int8_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); +bool TryCastFromDecimal::Operation(int32_t input, int8_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); +bool TryCastFromDecimal::Operation(int64_t input, int8_t &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, int8_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, int8_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastHugeDecimalToNumeric(input, result, error_message, scale); + return TryCastHugeDecimalToNumeric(input, result, parameters, scale); } //===--------------------------------------------------------------------===// // Cast Decimal -> int16_t //===--------------------------------------------------------------------===// template <> -bool TryCastFromDecimal::Operation(int16_t input, int16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, int16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, int16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, int16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, int16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastHugeDecimalToNumeric(input, result, error_message, scale); + return TryCastHugeDecimalToNumeric(input, result, parameters, scale); } //===--------------------------------------------------------------------===// // Cast Decimal -> int32_t //===--------------------------------------------------------------------===// template <> -bool TryCastFromDecimal::Operation(int16_t input, int32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, int32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, int32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, int32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, int32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastHugeDecimalToNumeric(input, result, error_message, scale); + return TryCastHugeDecimalToNumeric(input, result, parameters, scale); } //===--------------------------------------------------------------------===// // Cast Decimal -> int64_t //===--------------------------------------------------------------------===// template <> -bool TryCastFromDecimal::Operation(int16_t input, int64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, int64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, int64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, int64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, int64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastHugeDecimalToNumeric(input, result, error_message, scale); + return TryCastHugeDecimalToNumeric(input, result, parameters, scale); } //===--------------------------------------------------------------------===// // Cast Decimal -> uint8_t //===--------------------------------------------------------------------===// template <> -bool TryCastFromDecimal::Operation(int16_t input, uint8_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, uint8_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, uint8_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, uint8_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, uint8_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, uint8_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, uint8_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, uint8_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastHugeDecimalToNumeric(input, result, error_message, scale); + return TryCastHugeDecimalToNumeric(input, result, parameters, scale); } //===--------------------------------------------------------------------===// // Cast Decimal -> uint16_t //===--------------------------------------------------------------------===// template <> -bool TryCastFromDecimal::Operation(int16_t input, uint16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, uint16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, uint16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, uint16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, uint16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, uint16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, uint16_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, uint16_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastHugeDecimalToNumeric(input, result, error_message, scale); + return TryCastHugeDecimalToNumeric(input, result, parameters, scale); } //===--------------------------------------------------------------------===// // Cast Decimal -> uint32_t //===--------------------------------------------------------------------===// template <> -bool TryCastFromDecimal::Operation(int16_t input, uint32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, uint32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, uint32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, uint32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, uint32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, uint32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, uint32_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, uint32_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastHugeDecimalToNumeric(input, result, error_message, scale); + return TryCastHugeDecimalToNumeric(input, result, parameters, scale); } //===--------------------------------------------------------------------===// // Cast Decimal -> uint64_t //===--------------------------------------------------------------------===// template <> -bool TryCastFromDecimal::Operation(int16_t input, uint64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, uint64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, uint64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, uint64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, uint64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, uint64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, uint64_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, uint64_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastHugeDecimalToNumeric(input, result, error_message, scale); + return TryCastHugeDecimalToNumeric(input, result, parameters, scale); } //===--------------------------------------------------------------------===// // Cast Decimal -> hugeint_t //===--------------------------------------------------------------------===// template <> -bool TryCastFromDecimal::Operation(int16_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, hugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, hugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastHugeDecimalToNumeric(input, result, error_message, scale); + return TryCastHugeDecimalToNumeric(input, result, parameters, scale); } //===--------------------------------------------------------------------===// // Cast Decimal -> uhugeint_t //===--------------------------------------------------------------------===// template <> -bool TryCastFromDecimal::Operation(int16_t input, uhugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int16_t input, uhugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, uhugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int32_t input, uhugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, uhugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(int64_t input, uhugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastDecimalToNumeric(input, result, error_message, scale); + return TryCastDecimalToNumeric(input, result, parameters, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, uhugeint_t &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, uhugeint_t &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { - return TryCastHugeDecimalToNumeric(input, result, error_message, scale); + return TryCastHugeDecimalToNumeric(input, result, parameters, scale); } //===--------------------------------------------------------------------===// @@ -66067,44 +66721,50 @@ bool TryCastDecimalToFloatingPoint(SRC input, DST &result, uint8_t scale) { // DECIMAL -> FLOAT template <> -bool TryCastFromDecimal::Operation(int16_t input, float &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryCastFromDecimal::Operation(int16_t input, float &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { return TryCastDecimalToFloatingPoint(input, result, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, float &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryCastFromDecimal::Operation(int32_t input, float &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { return TryCastDecimalToFloatingPoint(input, result, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, float &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryCastFromDecimal::Operation(int64_t input, float &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { return TryCastDecimalToFloatingPoint(input, result, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, float &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, float &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { return TryCastDecimalToFloatingPoint(input, result, scale); } // DECIMAL -> DOUBLE template <> -bool TryCastFromDecimal::Operation(int16_t input, double &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryCastFromDecimal::Operation(int16_t input, double &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { return TryCastDecimalToFloatingPoint(input, result, scale); } template <> -bool TryCastFromDecimal::Operation(int32_t input, double &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryCastFromDecimal::Operation(int32_t input, double &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { return TryCastDecimalToFloatingPoint(input, result, scale); } template <> -bool TryCastFromDecimal::Operation(int64_t input, double &result, string *error_message, uint8_t width, uint8_t scale) { +bool TryCastFromDecimal::Operation(int64_t input, double &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { return TryCastDecimalToFloatingPoint(input, result, scale); } template <> -bool TryCastFromDecimal::Operation(hugeint_t input, double &result, string *error_message, uint8_t width, +bool TryCastFromDecimal::Operation(hugeint_t input, double &result, CastParameters ¶meters, uint8_t width, uint8_t scale) { return TryCastDecimalToFloatingPoint(input, result, scale); } @@ -70757,6 +71417,7 @@ void RandomEngine::SetSeed(uint32_t seed) { } // namespace duckdb + #include // RE2 compatibility layer with std::regex @@ -70856,7 +71517,7 @@ bool RegexSearchInternal(const char *input, Match &match, const Regex &r, RE2::A for (auto &group : target_groups) { GroupMatch group_match; group_match.text = group.ToString(); - group_match.position = group.data() - input; + group_match.position = group.data() != nullptr ? duckdb::NumericCast(group.data() - input) : 0; match.groups.emplace_back(group_match); } return true; @@ -72136,7 +72797,7 @@ static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVect if (vdata.validity.RowIsValid(source_idx)) { auto &string_entry = strings[source_idx]; // store string size - Store(string_entry.GetSize(), key_locations[i]); + Store(NumericCast(string_entry.GetSize()), key_locations[i]); key_locations[i] += sizeof(uint32_t); // store the string memcpy(key_locations[i], string_entry.GetData(), string_entry.GetSize()); @@ -72150,7 +72811,7 @@ static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVect if (vdata.validity.RowIsValid(source_idx)) { auto &string_entry = strings[source_idx]; // store string size - Store(string_entry.GetSize(), key_locations[i]); + Store(NumericCast(string_entry.GetSize()), key_locations[i]); key_locations[i] += sizeof(uint32_t); // store the string memcpy(key_locations[i], string_entry.GetData(), string_entry.GetSize()); @@ -72699,6 +73360,7 @@ static idx_t GenericNestedMatch(Vector &lhs_vector, const TupleDataVectorFormat const auto gather_function = TupleDataCollection::GetGatherFunction(type); gather_function.function(rhs_layout, rhs_row_locations, col_idx, sel, count, key, *FlatVector::IncrementalSelectionVector(), nullptr, gather_function.child_functions); + Vector::Verify(key, *FlatVector::IncrementalSelectionVector(), count); // Densify the input column Vector sliced(lhs_vector, sel, count); @@ -72923,6 +73585,7 @@ MatchFunction RowMatcher::GetListMatchFunction(const ExpressionType predicate) { + namespace duckdb { #define BSWAP16(x) ((uint16_t)((((uint16_t)(x)&0xff00) >> 8) | (((uint16_t)(x)&0x00ff) << 8))) @@ -72946,9 +73609,12 @@ static inline T BSwap(const T &x) { } else if (sizeof(T) == 2) { return BSWAP16(x); } else if (sizeof(T) == 4) { - return BSWAP32(x); + // this check is superfluous as the branch is not taken for small return types but the compiler does not realize + // that + return UnsafeNumericCast(BSWAP32(x)); } else { - return BSWAP64(x); + // see above + return UnsafeNumericCast(BSWAP64(x)); } } @@ -72995,7 +73661,7 @@ struct Radix { } static inline uint32_t EncodeFloat(float x) { - uint64_t buff; + uint32_t buff; //! zero if (x == 0) { @@ -73543,7 +74209,7 @@ static void ScatterStringVector(UnifiedVectorFormat &col, Vector &rows, data_ptr Store(string_data[col_idx], row + col_offset); } else { const auto &str = string_data[col_idx]; - string_t inserted(const_char_ptr_cast(str_locations[i]), str.GetSize()); + string_t inserted(const_char_ptr_cast(str_locations[i]), UnsafeNumericCast(str.GetSize())); memcpy(inserted.GetDataWriteable(), str.GetData(), str.GetSize()); str_locations[i] += str.GetSize(); inserted.Finalize(); @@ -73628,7 +74294,7 @@ void RowOperations::Scatter(DataChunk &columns, UnifiedVectorFormat col_data[], // Pointer to this row in the heap block Store(data_locations[i], row + heap_pointer_offset); // Row size is stored in the heap in front of each row - Store(entry_sizes[i], data_locations[i]); + Store(NumericCast(entry_sizes[i]), data_locations[i]); data_locations[i] += sizeof(uint32_t); } } @@ -73987,19 +74653,19 @@ void BinarySerializer::WriteValue(double value) { } void BinarySerializer::WriteValue(const string &value) { - uint32_t len = value.length(); + auto len = NumericCast(value.length()); VarIntEncode(len); WriteData(value.c_str(), len); } void BinarySerializer::WriteValue(const string_t value) { - uint32_t len = value.GetSize(); + auto len = NumericCast(value.GetSize()); VarIntEncode(len); WriteData(value.GetDataUnsafe(), len); } void BinarySerializer::WriteValue(const char *value) { - uint32_t len = strlen(value); + auto len = NumericCast(strlen(value)); VarIntEncode(len); WriteData(value, len); } @@ -75585,7 +76251,10 @@ class ColumnDataCollectionSegment { } idx_t ChunkCount() const; + //! Get the total *used* size (not cached) idx_t SizeInBytes() const; + //! Get the currently allocated size in bytes (cached) + idx_t AllocationSize() const; void FetchChunk(idx_t chunk_idx, DataChunk &result); void FetchChunk(idx_t chunk_idx, DataChunk &result, const vector &column_ids); @@ -76242,7 +76911,7 @@ class PartitionMergeTask : public ExecutorTask { public: PartitionMergeTask(shared_ptr event_p, ClientContext &context_p, PartitionGlobalMergeStates &hash_groups_p, PartitionGlobalSinkState &gstate) - : ExecutorTask(context_p), event(std::move(event_p)), local_state(gstate), hash_groups(hash_groups_p) { + : ExecutorTask(context_p, std::move(event_p)), local_state(gstate), hash_groups(hash_groups_p) { } TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override; @@ -76259,7 +76928,6 @@ class PartitionMergeTask : public ExecutorTask { Executor &executor; }; - shared_ptr event; PartitionLocalMergeState local_state; PartitionGlobalMergeStates &hash_groups; }; @@ -76754,7 +77422,7 @@ inline std::pair partition_right_branchless(const PDQIterator // Fill the offset blocks. if (left_split >= block_size) { - for (size_t i = 0; i < block_size;) { + for (unsigned char i = 0; i < block_size;) { offsets_l[num_l] = i++; num_l += !comp(*first, pivot, constants); ++first; @@ -76781,7 +77449,7 @@ inline std::pair partition_right_branchless(const PDQIterator ++first; } } else { - for (size_t i = 0; i < left_split;) { + for (unsigned char i = 0; i < left_split;) { offsets_l[num_l] = i++; num_l += !comp(*first, pivot, constants); ++first; @@ -76789,7 +77457,7 @@ inline std::pair partition_right_branchless(const PDQIterator } if (right_split >= block_size) { - for (size_t i = 0; i < block_size;) { + for (unsigned char i = 0; i < block_size;) { offsets_r[num_r] = ++i; num_r += comp(*--last, pivot, constants); offsets_r[num_r] = ++i; @@ -76808,7 +77476,7 @@ inline std::pair partition_right_branchless(const PDQIterator num_r += comp(*--last, pivot, constants); } } else { - for (size_t i = 0; i < right_split;) { + for (unsigned char i = 0; i < right_split;) { offsets_r[num_r] = ++i; num_r += comp(*--last, pivot, constants); } @@ -77438,7 +78106,6 @@ struct BufferEvictionNode { idx_t timestamp; bool CanUnload(BlockHandle &handle_p); - shared_ptr TryGetBlockHandle(); }; @@ -77482,9 +78149,24 @@ class BufferPool { virtual EvictionResult EvictBlocks(MemoryTag tag, idx_t extra_memory, idx_t memory_limit, unique_ptr *buffer = nullptr); - //! Garbage collect eviction queue + //! Tries to dequeue an element from the eviction queue, but only after acquiring the purge queue lock. + bool TryDequeueWithLock(BufferEvictionNode &node); + //! Bulk purge dead nodes from the eviction queue. Then, enqueue those that are still alive. + void PurgeIteration(const idx_t purge_size); + //! Garbage collect dead nodes in the eviction queue. void PurgeQueue(); - void AddToEvictionQueue(shared_ptr &handle); + //! Add a buffer handle to the eviction queue. Returns true, if the queue is + //! ready to be purged, and false otherwise. + bool AddToEvictionQueue(shared_ptr &handle); + + //! Increment the dead node counter in the purge queue. + inline void IncrementDeadNodes() { + total_dead_nodes++; + } + //! Decrement the dead node counter in the purge queue. + inline void DecrementDeadNodes() { + total_dead_nodes--; + } protected: //! The lock for changing the memory limit @@ -77495,12 +78177,33 @@ class BufferPool { atomic maximum_memory; //! Eviction queue unique_ptr queue; - //! Total number of insertions into the eviction queue. This guides the schedule for calling PurgeQueue. - atomic queue_insertions; //! Memory manager for concurrently used temporary memory, e.g., for physical operators unique_ptr temporary_memory_manager; //! Memory usage per tag atomic memory_usage_per_tag[MEMORY_TAG_COUNT]; + + //! We trigger a purge of the eviction queue every INSERT_INTERVAL insertions + constexpr static idx_t INSERT_INTERVAL = 4096; + //! We multiply the base purge size by this value. + constexpr static idx_t PURGE_SIZE_MULTIPLIER = 2; + //! We multiply the purge size by this value to determine early-outs. This is the minimum queue size. + //! We never purge below this point. + constexpr static idx_t EARLY_OUT_MULTIPLIER = 4; + //! We multiply the approximate alive nodes by this value to test whether our total dead nodes + //! exceed their allowed ratio. Must be greater than 1. + constexpr static idx_t ALIVE_NODE_MULTIPLIER = 4; + + //! Total number of insertions into the eviction queue. This guides the schedule for calling PurgeQueue. + atomic evict_queue_insertions; + //! Total dead nodes in the eviction queue. There are two scenarios in which a node dies: (1) we destroy its block + //! handle, or (2) we insert a newer version into the eviction queue. + atomic total_dead_nodes; + //! Locked, if a queue purge is currently active or we're trying to forcefully evict a node. + //! Only lets a single thread enter the purge phase. + mutex purge_lock; + + //! A pre-allocated vector of eviction nodes. We reuse this to keep the allocation overhead of purges small. + vector purge_nodes; }; } // namespace duckdb @@ -78415,13 +79118,13 @@ void StringUtil::LTrim(string &str) { // Remove trailing ' ', '\f', '\n', '\r', '\t', '\v' void StringUtil::RTrim(string &str) { - str.erase(find_if(str.rbegin(), str.rend(), [](int ch) { return ch > 0 && !CharacterIsSpace(ch); }).base(), + str.erase(find_if(str.rbegin(), str.rend(), [](char ch) { return ch > 0 && !CharacterIsSpace(ch); }).base(), str.end()); } void StringUtil::RTrim(string &str, const string &chars_to_trim) { str.erase(find_if(str.rbegin(), str.rend(), - [&chars_to_trim](int ch) { return ch > 0 && chars_to_trim.find(ch) == string::npos; }) + [&chars_to_trim](char ch) { return ch > 0 && chars_to_trim.find(ch) == string::npos; }) .base(), str.end()); } @@ -78726,7 +79429,7 @@ idx_t StringUtil::LevenshteinDistance(const string &s1_p, const string &s2_p, id // d[i][j] = std::min({ d[i - 1][j] + 1, // d[i][j - 1] + 1, // d[i - 1][j - 1] + (s1[i - 1] == s2[j - 1] ? 0 : 1) }); - int equal = s1[i - 1] == s2[j - 1] ? 0 : not_equal_penalty; + auto equal = s1[i - 1] == s2[j - 1] ? 0 : not_equal_penalty; idx_t adjacent_score1 = array.Score(i - 1, j) + 1; idx_t adjacent_score2 = array.Score(i, j - 1) + 1; idx_t adjacent_score3 = array.Score(i - 1, j - 1) + equal; @@ -80389,6 +81092,7 @@ void BatchedDataCollection::Print() const { + namespace duckdb { // **** helper functions **** @@ -80514,7 +81218,7 @@ void Bit::ToBit(string_t str, string_t &output_str) { } } if (padded_byte != 0) { - *(output++) = (8 - padded_byte); // the first byte contains the number of padded zeroes + *(output++) = UnsafeNumericCast((8 - padded_byte)); // the first byte contains the number of padded zeroes } *(output++) = byte; @@ -80535,7 +81239,7 @@ void Bit::ToBit(string_t str, string_t &output_str) { string Bit::ToBit(string_t str) { auto bit_len = GetBitSize(str); auto buffer = make_unsafe_uniq_array(bit_len); - string_t output_str(buffer.get(), bit_len); + string_t output_str(buffer.get(), UnsafeNumericCast(bit_len)); Bit::ToBit(str, output_str); return output_str.GetString(); } @@ -80551,7 +81255,7 @@ void Bit::BlobToBit(string_t blob, string_t &output_str) { string Bit::BlobToBit(string_t blob) { auto buffer = make_unsafe_uniq_array(blob.GetSize() + 1); - string_t output_str(buffer.get(), blob.GetSize() + 1); + string_t output_str(buffer.get(), UnsafeNumericCast(blob.GetSize() + 1)); Bit::BlobToBit(blob, output_str); return output_str.GetString(); } @@ -80577,7 +81281,7 @@ string Bit::BitToBlob(string_t bit) { D_ASSERT(bit.GetSize() > 1); auto buffer = make_unsafe_uniq_array(bit.GetSize() - 1); - string_t output_str(buffer.get(), bit.GetSize() - 1); + string_t output_str(buffer.get(), UnsafeNumericCast(bit.GetSize() - 1)); Bit::BitToBlob(bit, output_str); return output_str.GetString(); } @@ -80674,11 +81378,11 @@ void Bit::SetBit(string_t &bit_string, idx_t n, idx_t new_value) { } void Bit::SetBitInternal(string_t &bit_string, idx_t n, idx_t new_value) { - char *buf = bit_string.GetDataWriteable(); + auto buf = bit_string.GetDataWriteable(); auto idx = Bit::GetBitIndex(n); D_ASSERT(idx < bit_string.GetSize()); - char shift_byte = 1 << (7 - (n % 8)); + auto shift_byte = UnsafeNumericCast(1 << (7 - (n % 8))); if (new_value == 0) { shift_byte = ~shift_byte; buf[idx] &= shift_byte; @@ -80798,6 +81502,7 @@ void Bit::Verify(const string_t &input) { + namespace duckdb { constexpr const char *Blob::HEX_TABLE; @@ -80862,7 +81567,7 @@ string Blob::ToString(string_t blob) { return string(buffer.get(), str_len); } -bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) { +bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, CastParameters ¶meters) { auto data = const_data_ptr_cast(str.GetData()); auto len = str.GetSize(); str_len = 0; @@ -80871,14 +81576,14 @@ bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) { if (i + 3 >= len) { string error = "Invalid hex escape code encountered in string -> blob conversion: " "unterminated escape code at end of blob"; - HandleCastError::AssignError(error, error_message); + HandleCastError::AssignError(error, parameters); return false; } if (data[i + 1] != 'x' || Blob::HEX_MAP[data[i + 2]] < 0 || Blob::HEX_MAP[data[i + 3]] < 0) { string error = StringUtil::Format("Invalid hex escape code encountered in string -> blob conversion: %s", string(const_char_ptr_cast(data) + i, 4)); - HandleCastError::AssignError(error, error_message); + HandleCastError::AssignError(error, parameters); return false; } str_len++; @@ -80888,7 +81593,7 @@ bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) { } else { string error = "Invalid byte encountered in STRING -> BLOB conversion. All non-ascii characters " "must be escaped with hex codes (e.g. \\xAA)"; - HandleCastError::AssignError(error, error_message); + HandleCastError::AssignError(error, parameters); return false; } } @@ -80896,10 +81601,15 @@ bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) { } idx_t Blob::GetBlobSize(string_t str) { - string error_message; + CastParameters parameters; + return GetBlobSize(str, parameters); +} + +idx_t Blob::GetBlobSize(string_t str, CastParameters ¶meters) { idx_t str_len; - if (!Blob::TryGetBlobSize(str, str_len, &error_message)) { - throw ConversionException(error_message); + auto result = Blob::TryGetBlobSize(str, str_len, parameters); + if (!result) { + throw InternalException("Blob::TryGetBlobSize failed but no exception was thrown!?"); } return str_len; } @@ -80915,7 +81625,7 @@ void Blob::ToBlob(string_t str, data_ptr_t output) { D_ASSERT(i + 3 < len); D_ASSERT(byte_a >= 0 && byte_b >= 0); D_ASSERT(data[i + 1] == 'x'); - output[blob_idx++] = (byte_a << 4) + byte_b; + output[blob_idx++] = UnsafeNumericCast((byte_a << 4) + byte_b); i += 3; } else if (data[i] <= 127) { output[blob_idx++] = data_t(data[i]); @@ -80928,7 +81638,12 @@ void Blob::ToBlob(string_t str, data_ptr_t output) { } string Blob::ToBlob(string_t str) { - auto blob_len = GetBlobSize(str); + CastParameters parameters; + return Blob::ToBlob(str, parameters); +} + +string Blob::ToBlob(string_t str, CastParameters ¶meters) { + auto blob_len = GetBlobSize(str, parameters); auto buffer = make_unsafe_uniq_array(blob_len); Blob::ToBlob(str, data_ptr_cast(buffer.get())); return string(buffer.get(), blob_len); @@ -81239,9 +81954,10 @@ BufferHandle ColumnDataAllocator::AllocateBlock(idx_t size) { auto block_size = MaxValue(size, Storage::BLOCK_SIZE); BlockMetaData data; data.size = 0; - data.capacity = block_size; + data.capacity = NumericCast(block_size); auto pin = alloc.buffer_manager->Allocate(MemoryTag::COLUMN_DATA, block_size, false, &data.handle); blocks.push_back(std::move(data)); + allocated_size += block_size; return pin; } @@ -81255,9 +81971,10 @@ void ColumnDataAllocator::AllocateEmptyBlock(idx_t size) { D_ASSERT(type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR); BlockMetaData data; data.size = 0; - data.capacity = allocation_amount; + data.capacity = NumericCast(allocation_amount); data.handle = nullptr; blocks.push_back(std::move(data)); + allocated_size += allocation_amount; } void ColumnDataAllocator::AssignPointer(uint32_t &block_id, uint32_t &offset, data_ptr_t pointer) { @@ -81285,7 +82002,7 @@ void ColumnDataAllocator::AllocateBuffer(idx_t size, uint32_t &block_id, uint32_ } auto &block = blocks.back(); D_ASSERT(size <= block.capacity - block.size); - block_id = blocks.size() - 1; + block_id = NumericCast(blocks.size() - 1); if (chunk_state && chunk_state->handles.find(block_id) == chunk_state->handles.end()) { // not guaranteed to be pinned already by this thread (if shared allocator) chunk_state->handles[block_id] = alloc.buffer_manager->Pin(blocks[block_id].handle); @@ -81361,8 +82078,8 @@ void ColumnDataAllocator::UnswizzlePointers(ChunkManagementState &state, Vector auto strings = FlatVector::GetData(result); // find first non-inlined string - uint32_t i = v_offset; - const uint32_t end = v_offset + count; + auto i = NumericCast(v_offset); + const uint32_t end = NumericCast(v_offset + count); for (; i < end; i++) { if (!validity.RowIsValid(i)) { continue; @@ -81412,7 +82129,7 @@ void ColumnDataAllocator::InitializeChunkState(ChunkManagementState &state, Chun do { found_handle = false; for (auto it = state.handles.begin(); it != state.handles.end(); it++) { - if (chunk.block_ids.find(it->first) != chunk.block_ids.end()) { + if (chunk.block_ids.find(NumericCast(it->first)) != chunk.block_ids.end()) { // still required: do not release continue; } @@ -81585,6 +82302,14 @@ idx_t ColumnDataCollection::SizeInBytes() const { return total_size; } +idx_t ColumnDataCollection::AllocationSize() const { + idx_t total_size = 0; + for (const auto &segment : segments) { + total_size += segment->AllocationSize(); + } + return total_size; +} + //===--------------------------------------------------------------------===// // ColumnDataRow //===--------------------------------------------------------------------===// @@ -81763,6 +82488,7 @@ const ColumnDataRow &ColumnDataRowIterationHelper::ColumnDataRowIterator::operat //===--------------------------------------------------------------------===// void ColumnDataCollection::InitializeAppend(ColumnDataAppendState &state) { D_ASSERT(!finished_append); + state.current_chunk_state.handles.clear(); state.vector_data.resize(types.size()); if (segments.empty()) { CreateSegment(); @@ -82006,7 +82732,8 @@ void ColumnDataCopy(ColumnDataMetaData &meta_data, const UnifiedVector } else { D_ASSERT(heap_ptr != nullptr); memcpy(heap_ptr, source_entry.GetData(), source_entry.GetSize()); - target_entry = string_t(const_char_ptr_cast(heap_ptr), source_entry.GetSize()); + target_entry = + string_t(const_char_ptr_cast(heap_ptr), UnsafeNumericCast(source_entry.GetSize())); heap_ptr += source_entry.GetSize(); } } @@ -82890,6 +83617,11 @@ idx_t ColumnDataCollectionSegment::SizeInBytes() const { return allocator->SizeInBytes() + heap->SizeInBytes(); } +idx_t ColumnDataCollectionSegment::AllocationSize() const { + D_ASSERT(!allocator->IsShared()); + return allocator->AllocationSize() + heap->AllocationSize(); +} + void ColumnDataCollectionSegment::FetchChunk(idx_t chunk_idx, DataChunk &result) { vector column_ids; column_ids.reserve(types.size()); @@ -83113,7 +83845,7 @@ void PartitionedColumnData::Append(PartitionedColumnDataAppendState &state, Data for (idx_t i = 0; i < count; i++) { const auto &partition_index = partition_indices[i]; auto &partition_offset = partition_entries[partition_index].offset; - all_partitions_sel[partition_offset++] = i; + all_partitions_sel[partition_offset++] = NumericCast(i); } // Loop through the partitions to append the new data to the partition buffers, and flush the buffers if necessary @@ -83707,7 +84439,7 @@ void DataChunk::Serialize(Serializer &serializer) const { // write the count auto row_count = size(); - serializer.WriteProperty(100, "rows", row_count); + serializer.WriteProperty(100, "rows", NumericCast(row_count)); // we should never try to serialize empty data chunks auto column_count = ColumnCount(); @@ -84270,7 +85002,7 @@ int32_t Date::EpochDays(date_t date) { } date_t Date::EpochToDate(int64_t epoch) { - return date_t(epoch / Interval::SECS_PER_DAY); + return date_t(UnsafeNumericCast(epoch / Interval::SECS_PER_DAY)); } int64_t Date::Epoch(date_t date) { @@ -84663,6 +85395,7 @@ hash_t Hash(uint8_t *val, size_t size) { + #include #include @@ -84820,7 +85553,7 @@ string Hugeint::ToString(hugeint_t input) { break; } input = Hugeint::DivModPositive(input, 10, remainder); - result = string(1, '0' + remainder) + result; // NOLINT + result = string(1, UnsafeNumericCast('0' + remainder)) + result; // NOLINT } if (result.empty()) { // value is zero @@ -85332,7 +86065,7 @@ bool Hugeint::TryConvert(int8_t value, hugeint_t &result) { template <> bool Hugeint::TryConvert(const char *value, hugeint_t &result) { auto len = strlen(value); - string_t string_val(value, len); + string_t string_val(value, UnsafeNumericCast(len)); return TryCast::Operation(string_val, result, true); } @@ -86037,7 +86770,7 @@ bool Interval::FromCString(const char *str, idx_t len, interval_t &result, strin return false; } // finished the number, parse it from the string - string_t nr_string(str + start_pos, pos - start_pos); + string_t nr_string(str + start_pos, UnsafeNumericCast(pos - start_pos)); number = Cast::Operation(nr_string); fraction = 0; if (c == '.') { @@ -86517,6 +87250,7 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType + namespace duckdb { // forward declarations @@ -86706,7 +87440,7 @@ static ListSegment *GetSegment(const ListSegmentFunctions &functions, ArenaAlloc if (!linked_list.last_segment) { // empty linked list, create the first (and last) segment auto capacity = ListSegment::INITIAL_CAPACITY; - segment = functions.create_segment(functions, allocator, capacity); + segment = functions.create_segment(functions, allocator, UnsafeNumericCast(capacity)); linked_list.first_segment = segment; linked_list.last_segment = segment; @@ -87254,12 +87988,6 @@ void PartitionedTupleData::InitializeAppendState(PartitionedTupleDataAppendState state.partition_sel.Initialize(); state.reverse_partition_sel.Initialize(); - vector column_ids; - column_ids.reserve(layout.ColumnCount()); - for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) { - column_ids.emplace_back(col_idx); - } - InitializeAppendStateInternal(state, properties); } @@ -87445,7 +88173,7 @@ void PartitionedTupleData::BuildPartitionSel(PartitionedTupleDataAppendState &st // This needs to be initialized, even if we go the short path here for (idx_t i = 0; i < append_count; i++) { const auto index = append_sel.get_index(i); - state.reverse_partition_sel[index] = i; + state.reverse_partition_sel[index] = NumericCast(i); } return; } @@ -87465,8 +88193,8 @@ void PartitionedTupleData::BuildPartitionSel(PartitionedTupleDataAppendState &st const auto index = append_sel.get_index(i); const auto &partition_index = partition_indices[index]; auto &partition_offset = partition_entries[partition_index].offset; - reverse_partition_sel[index] = partition_offset; - partition_sel[partition_offset++] = index; + reverse_partition_sel[index] = UnsafeNumericCast(partition_offset); + partition_sel[partition_offset++] = UnsafeNumericCast(index); } } @@ -88294,12 +89022,12 @@ TupleDataChunkPart TupleDataAllocator::BuildChunkPart(TupleDataPinState &pin_sta if (row_blocks.empty() || row_blocks.back().RemainingCapacity() < layout.GetRowWidth()) { row_blocks.emplace_back(buffer_manager, (idx_t)Storage::BLOCK_SIZE); } - result.row_block_index = row_blocks.size() - 1; + result.row_block_index = NumericCast(row_blocks.size() - 1); auto &row_block = row_blocks[result.row_block_index]; - result.row_block_offset = row_block.size; + result.row_block_offset = NumericCast(row_block.size); // Set count (might be reduced later when checking heap space) - result.count = MinValue(row_block.RemainingCapacity(layout.GetRowWidth()), append_count); + result.count = NumericCast(MinValue(row_block.RemainingCapacity(layout.GetRowWidth()), append_count)); if (!layout.AllConstant()) { const auto heap_sizes = FlatVector::GetData(chunk_state.heap_sizes); @@ -88322,21 +89050,21 @@ TupleDataChunkPart TupleDataAllocator::BuildChunkPart(TupleDataPinState &pin_sta const auto size = MaxValue((idx_t)Storage::BLOCK_SIZE, heap_sizes[append_offset]); heap_blocks.emplace_back(buffer_manager, size); } - result.heap_block_index = heap_blocks.size() - 1; + result.heap_block_index = NumericCast(heap_blocks.size() - 1); auto &heap_block = heap_blocks[result.heap_block_index]; - result.heap_block_offset = heap_block.size; + result.heap_block_offset = NumericCast(heap_block.size); const auto heap_remaining = heap_block.RemainingCapacity(); if (total_heap_size <= heap_remaining) { // Everything fits - result.total_heap_size = total_heap_size; + result.total_heap_size = NumericCast(total_heap_size); } else { // Not everything fits - determine how many we can read next result.total_heap_size = 0; for (idx_t i = 0; i < result.count; i++) { const auto &heap_size = heap_sizes[append_offset + i]; if (result.total_heap_size + heap_size > heap_remaining) { - result.count = i; + result.count = NumericCast(i); break; } result.total_heap_size += heap_size; @@ -88874,27 +89602,7 @@ void TupleDataCollection::AppendUnified(TupleDataPinState &pin_state, TupleDataC } Build(pin_state, chunk_state, 0, actual_append_count); - -#ifdef DEBUG - Vector heap_locations_copy(LogicalType::POINTER); - if (!layout.AllConstant()) { - VectorOperations::Copy(chunk_state.heap_locations, heap_locations_copy, actual_append_count, 0, 0); - } -#endif - Scatter(chunk_state, new_chunk, append_sel, actual_append_count); - -#ifdef DEBUG - // Verify that the size of the data written to the heap is the same as the size we computed it would be - if (!layout.AllConstant()) { - const auto original_heap_locations = FlatVector::GetData(heap_locations_copy); - const auto heap_sizes = FlatVector::GetData(chunk_state.heap_sizes); - const auto offset_heap_locations = FlatVector::GetData(chunk_state.heap_locations); - for (idx_t i = 0; i < actual_append_count; i++) { - D_ASSERT(offset_heap_locations[i] == original_heap_locations[i] + heap_sizes[i]); - } - } -#endif } static inline void ToUnifiedFormatInternal(TupleDataVectorFormat &format, Vector &vector, const idx_t count) { @@ -88921,20 +89629,23 @@ static inline void ToUnifiedFormatInternal(TupleDataVectorFormat &format, Vector // For arrays, we cheat a bit and pretend that they are lists by creating and assigning list_entry_t's to the // vector This allows us to reuse all the list serialization functions for array types too. + auto array_size = ArrayType::GetSize(vector.GetType()); - // This is kind of hacky, but we need to create a list_entry_t for each array entry - idx_t array_count = ArrayVector::GetTotalSize(vector) / ArrayType::GetSize(vector.GetType()); - format.array_list_entries = make_uniq_array(array_count); + // How many list_entry_t's do we need to cover the whole child array? + // Make sure we round up so its all covered + auto child_array_total_size = ArrayVector::GetTotalSize(vector); + auto list_entry_t_count = MaxValue((child_array_total_size + array_size) / array_size, count); - auto array_size = ArrayType::GetSize(vector.GetType()); - // create list entries - for (idx_t i = 0; i < array_count; i++) { + // Create list entries! + format.array_list_entries = make_uniq_array(list_entry_t_count); + for (idx_t i = 0; i < list_entry_t_count; i++) { format.array_list_entries[i].length = array_size; format.array_list_entries[i].offset = i * array_size; } format.unified.data = reinterpret_cast(format.array_list_entries.get()); - ToUnifiedFormatInternal(format.children[0], ArrayVector::GetEntry(vector), ArrayVector::GetTotalSize(vector)); + ToUnifiedFormatInternal(reinterpret_cast(format.children[0]), + ArrayVector::GetEntry(vector), count * array_size); } break; default: break; @@ -89516,11 +90227,15 @@ static inline void TupleDataValueStore(const T &source, const data_ptr_t &row_lo template <> inline void TupleDataValueStore(const string_t &source, const data_ptr_t &row_location, const idx_t offset_in_row, data_ptr_t &heap_location) { +#ifdef DEBUG + source.VerifyCharacters(); +#endif if (source.IsInlined()) { Store(source, row_location + offset_in_row); } else { memcpy(heap_location, source.GetData(), source.GetSize()); - Store(string_t(const_char_ptr_cast(heap_location), source.GetSize()), row_location + offset_in_row); + Store(string_t(const_char_ptr_cast(heap_location), UnsafeNumericCast(source.GetSize())), + row_location + offset_in_row); heap_location += source.GetSize(); } } @@ -89534,11 +90249,30 @@ static inline void TupleDataWithinListValueStore(const T &source, const data_ptr template <> inline void TupleDataWithinListValueStore(const string_t &source, const data_ptr_t &location, data_ptr_t &heap_location) { - Store(source.GetSize(), location); +#ifdef DEBUG + source.VerifyCharacters(); +#endif + Store(NumericCast(source.GetSize()), location); memcpy(heap_location, source.GetData(), source.GetSize()); heap_location += source.GetSize(); } +template +inline void TupleDataValueVerify(const LogicalType &type, const T &value) { +#ifdef DEBUG + // NOP +#endif +} + +template <> +inline void TupleDataValueVerify(const LogicalType &type, const string_t &value) { +#ifdef DEBUG + if (type.id() == LogicalTypeId::VARCHAR) { + value.Verify(); + } +#endif +} + template static inline T TupleDataWithinListValueLoad(const data_ptr_t &location, data_ptr_t &heap_location) { return Load(location); @@ -89552,20 +90286,18 @@ inline string_t TupleDataWithinListValueLoad(const data_ptr_t &location, data_pt return result; } +static inline void ResetCombinedListData(vector &vector_data) { #ifdef DEBUG -static void ResetCombinedListData(vector &vector_data) { for (auto &vd : vector_data) { vd.combined_list_data = nullptr; ResetCombinedListData(vd.children); } -} #endif +} void TupleDataCollection::ComputeHeapSizes(TupleDataChunkState &chunk_state, const DataChunk &new_chunk, const SelectionVector &append_sel, const idx_t append_count) { -#ifdef DEBUG ResetCombinedListData(chunk_state.vector_data); -#endif auto heap_sizes = FlatVector::GetData(chunk_state.heap_sizes); std::fill_n(heap_sizes, new_chunk.size(), 0); @@ -89593,6 +90325,7 @@ void TupleDataCollection::ComputeHeapSizes(Vector &heap_sizes_v, const Vector &s auto heap_sizes = FlatVector::GetData(heap_sizes_v); + // Source const auto &source_vector_data = source_format.unified; const auto &source_sel = *source_vector_data.sel; const auto &source_validity = source_vector_data.validity; @@ -89698,7 +90431,7 @@ void TupleDataCollection::ComputeFixedWithinCollectionHeapSizes(Vector &heap_siz const SelectionVector &append_sel, const idx_t append_count, const UnifiedVectorFormat &list_data) { - // List data + // Parent list data const auto list_sel = *list_data.sel; const auto list_entries = UnifiedVectorFormat::GetData(list_data); const auto &list_validity = list_data.validity; @@ -89716,6 +90449,9 @@ void TupleDataCollection::ComputeFixedWithinCollectionHeapSizes(Vector &heap_siz // Get the current list length const auto &list_length = list_entries[list_idx].length; + if (list_length == 0) { + continue; + } // Size is validity mask and all values auto &heap_size = heap_sizes[i]; @@ -89729,17 +90465,17 @@ void TupleDataCollection::StringWithinCollectionComputeHeapSizes(Vector &heap_si const SelectionVector &append_sel, const idx_t append_count, const UnifiedVectorFormat &list_data) { + // Parent list data + const auto list_sel = *list_data.sel; + const auto list_entries = UnifiedVectorFormat::GetData(list_data); + const auto &list_validity = list_data.validity; + // Source const auto &source_data = source_format.unified; const auto &source_sel = *source_data.sel; const auto data = UnifiedVectorFormat::GetData(source_data); const auto &source_validity = source_data.validity; - // List data - const auto list_sel = *list_data.sel; - const auto list_entries = UnifiedVectorFormat::GetData(list_data); - const auto &list_validity = list_data.validity; - // Target auto heap_sizes = FlatVector::GetData(heap_sizes_v); @@ -89753,6 +90489,9 @@ void TupleDataCollection::StringWithinCollectionComputeHeapSizes(Vector &heap_si const auto &list_entry = list_entries[list_idx]; const auto &list_offset = list_entry.offset; const auto &list_length = list_entry.length; + if (list_length == 0) { + continue; + } // Size is validity mask and all string sizes auto &heap_size = heap_sizes[i]; @@ -89774,7 +90513,7 @@ void TupleDataCollection::StructWithinCollectionComputeHeapSizes(Vector &heap_si const SelectionVector &append_sel, const idx_t append_count, const UnifiedVectorFormat &list_data) { - // List data + // Parent list data const auto list_sel = *list_data.sel; const auto list_entries = UnifiedVectorFormat::GetData(list_data); const auto &list_validity = list_data.validity; @@ -89790,6 +90529,9 @@ void TupleDataCollection::StructWithinCollectionComputeHeapSizes(Vector &heap_si // Get the current list length const auto &list_length = list_entries[list_idx].length; + if (list_length == 0) { + continue; + } // Size is just the validity mask heap_sizes[i] += ValidityBytes::SizeInBytes(list_length); @@ -89837,17 +90579,20 @@ void TupleDataCollection::CollectionWithinCollectionComputeHeapSizes(Vector &hea const SelectionVector &append_sel, const idx_t append_count, const UnifiedVectorFormat &list_data) { - // List data (of the list Vector that "source_v" is in) + // Parent list data const auto list_sel = *list_data.sel; const auto list_entries = UnifiedVectorFormat::GetData(list_data); const auto &list_validity = list_data.validity; - // Child list ("source_v") + // Source const auto &child_list_data = source_format.unified; const auto child_list_sel = *child_list_data.sel; const auto child_list_entries = UnifiedVectorFormat::GetData(child_list_data); const auto &child_list_validity = child_list_data.validity; + // Target + auto heap_sizes = FlatVector::GetData(heap_sizes_v); + // Figure out actual child list size (can differ from ListVector::GetListSize if dict/const vector), // and we cannot use ConstantVector::ZeroSelectionVector because it may need to be longer than STANDARD_VECTOR_SIZE idx_t sum_of_sizes = 0; @@ -89856,9 +90601,14 @@ void TupleDataCollection::CollectionWithinCollectionComputeHeapSizes(Vector &hea if (!list_validity.RowIsValid(list_idx)) { continue; } + + // Get the current list entry const auto &list_entry = list_entries[list_idx]; const auto &list_offset = list_entry.offset; const auto &list_length = list_entry.length; + if (list_length == 0) { + continue; + } for (idx_t child_i = 0; child_i < list_length; child_i++) { const auto child_list_idx = child_list_sel.get_index(list_offset + child_i); @@ -89877,10 +90627,7 @@ void TupleDataCollection::CollectionWithinCollectionComputeHeapSizes(Vector &hea sum_of_sizes, source_v.GetType().InternalType() == PhysicalType::LIST ? ListVector::GetListSize(source_v) : ArrayVector::GetTotalSize(source_v)); - // Target - auto heap_sizes = FlatVector::GetData(heap_sizes_v); - - // Construct combined list entries and a selection vector for the child list child + D_ASSERT(source_format.children.size() == 1); auto &child_format = source_format.children[0]; #ifdef DEBUG // In debug mode this should be deleted by ResetCombinedListData @@ -89890,16 +90637,22 @@ void TupleDataCollection::CollectionWithinCollectionComputeHeapSizes(Vector &hea child_format.combined_list_data = make_uniq(); } auto &combined_list_data = *child_format.combined_list_data; - auto &combined_list_entries = combined_list_data.combined_list_entries; + + // Construct combined list entries and a selection/validity vector for the child list child SelectionVector combined_sel(child_list_child_count); for (idx_t i = 0; i < child_list_child_count; i++) { combined_sel.set_index(i, 0); } + auto &combined_list_entries = combined_list_data.combined_list_entries; + auto &combined_validity = combined_list_data.combined_validity; + combined_validity.SetAllValid(STANDARD_VECTOR_SIZE); idx_t combined_list_offset = 0; for (idx_t i = 0; i < append_count; i++) { - const auto list_idx = list_sel.get_index(append_sel.get_index(i)); + const auto append_idx = append_sel.get_index(i); + const auto list_idx = list_sel.get_index(append_idx); if (!list_validity.RowIsValid(list_idx)) { + combined_validity.SetInvalidUnsafe(append_idx); continue; // Original list entry is invalid - no need to serialize the child list } @@ -89916,10 +90669,13 @@ void TupleDataCollection::CollectionWithinCollectionComputeHeapSizes(Vector &hea idx_t child_list_size = 0; for (idx_t child_i = 0; child_i < list_length; child_i++) { const auto child_list_idx = child_list_sel.get_index(list_offset + child_i); - const auto &child_list_entry = child_list_entries[child_list_idx]; if (child_list_validity.RowIsValid(child_list_idx)) { + const auto &child_list_entry = child_list_entries[child_list_idx]; const auto &child_list_offset = child_list_entry.offset; const auto &child_list_length = child_list_entry.length; + if (child_list_length == 0) { + continue; + } // Add this child's list entries to the combined selection vector for (idx_t child_value_i = 0; child_value_i < child_list_length; child_value_i++) { @@ -89933,25 +90689,23 @@ void TupleDataCollection::CollectionWithinCollectionComputeHeapSizes(Vector &hea } // Combine the child list entries into one - combined_list_entries[list_idx] = {combined_list_offset, child_list_size}; + auto &combined_list_entry = combined_list_entries[append_idx]; + combined_list_entry.offset = combined_list_offset; + combined_list_entry.length = child_list_size; combined_list_offset += child_list_size; } - // Create a combined child_list_data to be used as list_data in the recursion - auto &combined_child_list_data = combined_list_data.combined_data; - combined_child_list_data.sel = list_data.sel; - combined_child_list_data.data = data_ptr_cast(combined_list_entries); - combined_child_list_data.validity = list_data.validity; - - // Combine the selection vectors - D_ASSERT(source_format.children.size() == 1); - // TODO: Template this? auto &child_source = source_v.GetType().InternalType() == PhysicalType::LIST ? ListVector::GetEntry(source_v) : ArrayVector::GetEntry(source_v); - ApplySliceRecursive(child_source, child_format, combined_sel, child_list_child_count); + // Create a combined child_list_data to be used as list_data in the recursion + auto &combined_child_list_data = combined_list_data.combined_data; + combined_child_list_data.sel = FlatVector::IncrementalSelectionVector(); + combined_child_list_data.data = data_ptr_cast(combined_list_entries); + combined_child_list_data.validity.Initialize(combined_validity); + // Recurse TupleDataCollection::WithinCollectionComputeHeapSizes(heap_sizes_v, child_source, child_format, append_sel, append_count, combined_child_list_data); @@ -89959,6 +90713,13 @@ void TupleDataCollection::CollectionWithinCollectionComputeHeapSizes(Vector &hea void TupleDataCollection::Scatter(TupleDataChunkState &chunk_state, const DataChunk &new_chunk, const SelectionVector &append_sel, const idx_t append_count) const { +#ifdef DEBUG + Vector heap_locations_copy(LogicalType::POINTER); + if (!layout.AllConstant()) { + VectorOperations::Copy(chunk_state.heap_locations, heap_locations_copy, append_count, 0, 0); + } +#endif + const auto row_locations = FlatVector::GetData(chunk_state.row_locations); // Set the validity mask for each row before inserting data @@ -89972,7 +90733,7 @@ void TupleDataCollection::Scatter(TupleDataChunkState &chunk_state, const DataCh const auto heap_size_offset = layout.GetHeapSizeOffset(); const auto heap_sizes = FlatVector::GetData(chunk_state.heap_sizes); for (idx_t i = 0; i < append_count; i++) { - Store(heap_sizes[i], row_locations[i] + heap_size_offset); + Store(NumericCast(heap_sizes[i]), row_locations[i] + heap_size_offset); } } @@ -89980,6 +90741,18 @@ void TupleDataCollection::Scatter(TupleDataChunkState &chunk_state, const DataCh for (const auto &col_idx : chunk_state.column_ids) { Scatter(chunk_state, new_chunk.data[col_idx], col_idx, append_sel, append_count); } + +#ifdef DEBUG + // Verify that the size of the data written to the heap is the same as the size we computed it would be + if (!layout.AllConstant()) { + const auto original_heap_locations = FlatVector::GetData(heap_locations_copy); + const auto heap_sizes = FlatVector::GetData(chunk_state.heap_sizes); + const auto offset_heap_locations = FlatVector::GetData(chunk_state.heap_locations); + for (idx_t i = 0; i < append_count; i++) { + D_ASSERT(offset_heap_locations[i] == original_heap_locations[i] + heap_sizes[i]); + } + } +#endif } void TupleDataCollection::Scatter(TupleDataChunkState &chunk_state, const Vector &source, const column_t column_id, @@ -90090,7 +90863,6 @@ static void TupleDataStructScatter(const Vector &source, const TupleDataVectorFo //------------------------------------------------------------------------------ // List Scatter //------------------------------------------------------------------------------ - static void TupleDataListScatter(const Vector &source, const TupleDataVectorFormat &source_format, const SelectionVector &append_sel, const idx_t append_count, const TupleDataLayout &layout, const Vector &row_locations, Vector &heap_locations, @@ -90139,7 +90911,6 @@ static void TupleDataListScatter(const Vector &source, const TupleDataVectorForm //------------------------------------------------------------------------------ // Array Scatter //------------------------------------------------------------------------------ - static void TupleDataArrayScatter(const Vector &source, const TupleDataVectorFormat &source_format, const SelectionVector &append_sel, const idx_t append_count, const TupleDataLayout &layout, const Vector &row_locations, Vector &heap_locations, @@ -90148,7 +90919,7 @@ static void TupleDataArrayScatter(const Vector &source, const TupleDataVectorFor // Source // The Array vector has fake list_entry_t's set by this point, so this is fine const auto &source_data = source_format.unified; - const auto source_sel = *source_data.sel; + const auto &source_sel = *source_data.sel; const auto data = UnifiedVectorFormat::GetData(source_data); const auto &validity = source_data.validity; @@ -90196,17 +90967,17 @@ static void TupleDataTemplatedWithinCollectionScatter(const Vector &source, cons Vector &heap_locations, const idx_t col_idx, const UnifiedVectorFormat &list_data, const vector &child_functions) { + // Parent list data + const auto &list_sel = *list_data.sel; + const auto list_entries = UnifiedVectorFormat::GetData(list_data); + const auto &list_validity = list_data.validity; + // Source const auto &source_data = source_format.unified; const auto &source_sel = *source_data.sel; const auto data = UnifiedVectorFormat::GetData(source_data); const auto &source_validity = source_data.validity; - // List data - const auto list_sel = *list_data.sel; - const auto list_entries = UnifiedVectorFormat::GetData(list_data); - const auto &list_validity = list_data.validity; - // Target auto target_heap_locations = FlatVector::GetData(heap_locations); @@ -90220,6 +90991,9 @@ static void TupleDataTemplatedWithinCollectionScatter(const Vector &source, cons const auto &list_entry = list_entries[list_idx]; const auto &list_offset = list_entry.offset; const auto &list_length = list_entry.length; + if (list_length == 0) { + continue; + } // Initialize validity mask and skip heap pointer over it auto &target_heap_location = target_heap_locations[i]; @@ -90251,16 +91025,16 @@ static void TupleDataStructWithinCollectionScatter(const Vector &source, const T Vector &heap_locations, const idx_t col_idx, const UnifiedVectorFormat &list_data, const vector &child_functions) { + // Parent list data + const auto &list_sel = *list_data.sel; + const auto list_entries = UnifiedVectorFormat::GetData(list_data); + const auto &list_validity = list_data.validity; + // Source const auto &source_data = source_format.unified; const auto &source_sel = *source_data.sel; const auto &source_validity = source_data.validity; - // List data - const auto list_sel = *list_data.sel; - const auto list_entries = UnifiedVectorFormat::GetData(list_data); - const auto &list_validity = list_data.validity; - // Target auto target_heap_locations = FlatVector::GetData(heap_locations); @@ -90275,6 +91049,9 @@ static void TupleDataStructWithinCollectionScatter(const Vector &source, const T const auto &list_entry = list_entries[list_idx]; const auto &list_offset = list_entry.offset; const auto &list_length = list_entry.length; + if (list_length == 0) { + continue; + } // Initialize validity mask and skip the heap pointer over it auto &target_heap_location = target_heap_locations[i]; @@ -90311,14 +91088,14 @@ static void TupleDataCollectionWithinCollectionScatter(const Vector &child_list, Vector &heap_locations, const idx_t col_idx, const UnifiedVectorFormat &list_data, const vector &child_functions) { - // List data (of the list Vector that "child_list" is in) - const auto list_sel = *list_data.sel; + // Parent list data + const auto &list_sel = *list_data.sel; const auto list_entries = UnifiedVectorFormat::GetData(list_data); const auto &list_validity = list_data.validity; - // Child list + // Source const auto &child_list_data = child_list_format.unified; - const auto child_list_sel = *child_list_data.sel; + const auto &child_list_sel = *child_list_data.sel; const auto child_list_entries = UnifiedVectorFormat::GetData(child_list_data); const auto &child_list_validity = child_list_data.validity; @@ -90335,6 +91112,9 @@ static void TupleDataCollectionWithinCollectionScatter(const Vector &child_list, const auto &list_entry = list_entries[list_idx]; const auto &list_offset = list_entry.offset; const auto &list_length = list_entry.length; + if (list_length == 0) { + continue; + } // Initialize validity mask and skip heap pointer over it auto &target_heap_location = target_heap_locations[i]; @@ -90449,7 +91229,6 @@ TupleDataScatterFunction TupleDataCollection::GetScatterFunction(const LogicalTy //------------------------------------------------------------------------------- // Gather //------------------------------------------------------------------------------- - void TupleDataCollection::Gather(Vector &row_locations, const SelectionVector &scan_sel, const idx_t scan_count, DataChunk &result, const SelectionVector &target_sel, vector> &cached_cast_vectors) const { @@ -90478,6 +91257,7 @@ void TupleDataCollection::Gather(Vector &row_locations, const SelectionVector &s const auto &gather_function = gather_functions[column_id]; gather_function.function(layout, row_locations, column_id, scan_sel, scan_count, result, target_sel, cached_cast_vector, gather_function.child_functions); + Vector::Verify(result, target_sel, scan_count); } template @@ -90504,6 +91284,7 @@ static void TupleDataTemplatedGather(const TupleDataLayout &layout, Vector &row_ ValidityBytes row_mask(source_row); if (row_mask.RowIsValid(row_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry)) { target_data[target_idx] = Load(source_row + offset_in_row); + TupleDataValueVerify(target.GetType(), target_data[target_idx]); } else { target_validity.SetInvalid(target_idx); } @@ -90571,7 +91352,7 @@ static void TupleDataListGather(const TupleDataLayout &layout, Vector &row_locat // Target auto target_list_entries = FlatVector::GetData(target); - auto &target_validity = FlatVector::Validity(target); + auto &target_list_validity = FlatVector::Validity(target); // Precompute mask indexes idx_t entry_idx; @@ -90581,18 +91362,16 @@ static void TupleDataListGather(const TupleDataLayout &layout, Vector &row_locat // Load pointers to the data from the row Vector heap_locations(LogicalType::POINTER); auto source_heap_locations = FlatVector::GetData(heap_locations); - auto &source_heap_validity = FlatVector::Validity(heap_locations); const auto offset_in_row = layout.GetOffsets()[col_idx]; uint64_t target_list_offset = 0; for (idx_t i = 0; i < scan_count; i++) { - const auto source_idx = scan_sel.get_index(i); - const auto target_idx = target_sel.get_index(i); - - const auto &source_row = source_locations[source_idx]; + const auto &source_row = source_locations[scan_sel.get_index(i)]; ValidityBytes row_mask(source_row); + + const auto target_idx = target_sel.get_index(i); if (row_mask.RowIsValid(row_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry)) { - auto &source_heap_location = source_heap_locations[source_idx]; + auto &source_heap_location = source_heap_locations[i]; source_heap_location = Load(source_row + offset_in_row); // Load list size and skip over @@ -90600,11 +91379,12 @@ static void TupleDataListGather(const TupleDataLayout &layout, Vector &row_locat source_heap_location += sizeof(uint64_t); // Initialize list entry, and increment offset - target_list_entries[target_idx] = {target_list_offset, list_length}; + auto &target_list_entry = target_list_entries[target_idx]; + target_list_entry.offset = target_list_offset; + target_list_entry.length = list_length; target_list_offset += list_length; } else { - source_heap_validity.SetInvalid(source_idx); - target_validity.SetInvalid(target_idx); + target_list_validity.SetInvalid(target_idx); } } auto list_size_before = ListVector::GetListSize(target); @@ -90628,28 +91408,31 @@ static void TupleDataTemplatedWithinCollectionGather(const TupleDataLayout &layo const SelectionVector &target_sel, optional_ptr list_vector, const vector &child_functions) { + // List parent + const auto list_entries = FlatVector::GetData(*list_vector); + const auto &list_validity = FlatVector::Validity(*list_vector); + // Source auto source_heap_locations = FlatVector::GetData(heap_locations); - auto &source_heap_validity = FlatVector::Validity(heap_locations); // Target auto target_data = FlatVector::GetData(target); auto &target_validity = FlatVector::Validity(target); - // List parent - const auto list_entries = FlatVector::GetData(*list_vector); - uint64_t target_offset = list_size_before; for (idx_t i = 0; i < scan_count; i++) { - const auto source_idx = scan_sel.get_index(i); - if (!source_heap_validity.RowIsValid(source_idx)) { + const auto target_idx = target_sel.get_index(i); + if (!list_validity.RowIsValid(target_idx)) { continue; } - const auto &list_length = list_entries[target_sel.get_index(i)].length; + const auto &list_length = list_entries[target_idx].length; + if (list_length == 0) { + continue; + } // Initialize validity mask - auto &source_heap_location = source_heap_locations[source_idx]; + auto &source_heap_location = source_heap_locations[i]; ValidityBytes source_mask(source_heap_location); source_heap_location += ValidityBytes::SizeInBytes(list_length); @@ -90660,8 +91443,10 @@ static void TupleDataTemplatedWithinCollectionGather(const TupleDataLayout &layo // Load the child validity and data belonging to this list entry for (idx_t child_i = 0; child_i < list_length; child_i++) { if (source_mask.RowIsValidUnsafe(child_i)) { - target_data[target_offset + child_i] = TupleDataWithinListValueLoad( + auto &target_value = target_data[target_offset + child_i]; + target_value = TupleDataWithinListValueLoad( source_data_location + child_i * TupleDataWithinListFixedSize(), source_heap_location); + TupleDataValueVerify(target.GetType(), target_value); } else { target_validity.SetInvalid(target_offset + child_i); } @@ -90675,27 +91460,30 @@ static void TupleDataStructWithinCollectionGather(const TupleDataLayout &layout, const idx_t scan_count, Vector &target, const SelectionVector &target_sel, optional_ptr list_vector, const vector &child_functions) { + // List parent + const auto list_entries = FlatVector::GetData(*list_vector); + const auto &list_validity = FlatVector::Validity(*list_vector); + // Source auto source_heap_locations = FlatVector::GetData(heap_locations); - auto &source_heap_validity = FlatVector::Validity(heap_locations); // Target auto &target_validity = FlatVector::Validity(target); - // List parent - const auto list_entries = FlatVector::GetData(*list_vector); - uint64_t target_offset = list_size_before; for (idx_t i = 0; i < scan_count; i++) { - const auto source_idx = scan_sel.get_index(i); - if (!source_heap_validity.RowIsValid(source_idx)) { + const auto target_idx = target_sel.get_index(i); + if (!list_validity.RowIsValid(target_idx)) { continue; } - const auto &list_length = list_entries[target_sel.get_index(i)].length; + const auto &list_length = list_entries[target_idx].length; + if (list_length == 0) { + continue; + } // Initialize validity mask and skip over it - auto &source_heap_location = source_heap_locations[source_idx]; + auto &source_heap_location = source_heap_locations[i]; ValidityBytes source_mask(source_heap_location); source_heap_location += ValidityBytes::SizeInBytes(list_length); @@ -90724,34 +91512,38 @@ static void TupleDataCollectionWithinCollectionGather(const TupleDataLayout &lay const SelectionVector &target_sel, optional_ptr list_vector, const vector &child_functions) { + // List parent + const auto list_entries = FlatVector::GetData(*list_vector); + const auto &list_validity = FlatVector::Validity(*list_vector); + // Source auto source_heap_locations = FlatVector::GetData(heap_locations); - auto &source_heap_validity = FlatVector::Validity(heap_locations); // Target auto target_list_entries = FlatVector::GetData(target); auto &target_validity = FlatVector::Validity(target); const auto child_list_size_before = ListVector::GetListSize(target); - // List parent - const auto list_entries = FlatVector::GetData(*list_vector); - // We need to create a vector that has the combined list sizes (hugeint_t has same size as list_entry_t) Vector combined_list_vector(LogicalType::HUGEINT); + FlatVector::SetValidity(combined_list_vector, list_validity); // Has same validity as list parent auto combined_list_entries = FlatVector::GetData(combined_list_vector); uint64_t target_offset = list_size_before; uint64_t target_child_offset = child_list_size_before; for (idx_t i = 0; i < scan_count; i++) { - const auto source_idx = scan_sel.get_index(i); - if (!source_heap_validity.RowIsValid(source_idx)) { + const auto target_idx = target_sel.get_index(i); + if (!list_validity.RowIsValid(target_idx)) { continue; } - const auto &list_length = list_entries[target_sel.get_index(i)].length; + const auto &list_length = list_entries[target_idx].length; + if (list_length == 0) { + continue; + } // Initialize validity mask and skip over it - auto &source_heap_location = source_heap_locations[source_idx]; + auto &source_heap_location = source_heap_locations[i]; ValidityBytes source_mask(source_heap_location); source_heap_location += ValidityBytes::SizeInBytes(list_length); @@ -90837,7 +91629,6 @@ static void TupleDataCastToArrayStructGather(const TupleDataLayout &layout, Vect //------------------------------------------------------------------------------ // Get Gather Function //------------------------------------------------------------------------------ - template tuple_data_gather_function_t TupleDataGetGatherFunction(bool within_collection) { return within_collection ? TupleDataTemplatedWithinCollectionGather : TupleDataTemplatedGather; @@ -91156,7 +91947,7 @@ buffer_ptr SelectionVector::Slice(const SelectionVector &sel, idx for (idx_t i = 0; i < count; i++) { auto new_idx = sel.get_index(i); auto idx = this->get_index(new_idx); - result_ptr[i] = idx; + result_ptr[i] = UnsafeNumericCast(idx); } return data; } @@ -91216,13 +92007,17 @@ string_t StringHeap::AddBlob(const string_t &data) { string_t StringHeap::EmptyString(idx_t len) { D_ASSERT(len > string_t::INLINE_LENGTH); auto insert_pos = const_char_ptr_cast(allocator.Allocate(len)); - return string_t(insert_pos, len); + return string_t(insert_pos, UnsafeNumericCast(len)); } idx_t StringHeap::SizeInBytes() const { return allocator.SizeInBytes(); } +idx_t StringHeap::AllocationSize() const { + return allocator.AllocationSize(); +} + } // namespace duckdb @@ -91230,20 +92025,34 @@ idx_t StringHeap::SizeInBytes() const { + namespace duckdb { void string_t::Verify() const { +#ifdef DEBUG + VerifyUTF8(); +#endif + + VerifyCharacters(); +} + +void string_t::VerifyUTF8() const { auto dataptr = GetData(); (void)dataptr; D_ASSERT(dataptr); -#ifdef DEBUG auto utf_type = Utf8Proc::Analyze(dataptr, GetSize()); + (void)utf_type; D_ASSERT(utf_type != UnicodeType::INVALID); -#endif +} + +void string_t::VerifyCharacters() const { + auto dataptr = GetData(); + (void)dataptr; + D_ASSERT(dataptr); // verify that the prefix contains the first four characters of the string - for (idx_t i = 0; i < MinValue(PREFIX_LENGTH, GetSize()); i++) { + for (idx_t i = 0; i < MinValue(PREFIX_LENGTH, GetSize()); i++) { D_ASSERT(GetPrefix()[i] == dataptr[i]); } // verify that for strings with length <= INLINE_LENGTH, the rest of the string is zero @@ -91392,8 +92201,9 @@ bool Time::TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &resul return result.micros <= Interval::MICROS_PER_DAY; } -bool Time::TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &result, bool strict) { +bool Time::TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &result, bool &has_offset, bool strict) { dtime_t time_part; + has_offset = false; if (!Time::TryConvertInternal(buf, len, pos, time_part, false)) { if (!strict) { // last chance, check if we can parse as timestamp @@ -91417,7 +92227,8 @@ bool Time::TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t & // Get the ±HH[:MM] part int hh = 0; int mm = 0; - if (pos < len && !Timestamp::TryParseUTCOffset(buf, pos, len, hh, mm)) { + has_offset = (pos < len); + if (has_offset && !Timestamp::TryParseUTCOffset(buf, pos, len, hh, mm)) { return false; } @@ -91678,7 +92489,7 @@ bool Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &r } auto tz_len = str + pos - tz_name; if (tz_len) { - tz = string_t(tz_name, tz_len); + tz = string_t(tz_name, UnsafeNumericCast(tz_len)); } // Note that the caller must reinterpret the instant we return to the given time zone } @@ -91878,7 +92689,7 @@ timestamp_t Timestamp::GetCurrentTimestamp() { return Timestamp::FromEpochMs(epoch_ms); } -timestamp_t Timestamp::FromEpochSeconds(int64_t sec) { +timestamp_t Timestamp::FromEpochSecondsPossiblyInfinite(int64_t sec) { int64_t result; if (!TryMultiplyOperator::Operation(sec, Interval::MICROS_PER_SEC, result)) { throw ConversionException("Could not convert Timestamp(S) to Timestamp(US)"); @@ -91886,7 +92697,12 @@ timestamp_t Timestamp::FromEpochSeconds(int64_t sec) { return timestamp_t(result); } -timestamp_t Timestamp::FromEpochMs(int64_t ms) { +timestamp_t Timestamp::FromEpochSeconds(int64_t sec) { + D_ASSERT(Timestamp::IsFinite(timestamp_t(sec))); + return FromEpochSecondsPossiblyInfinite(sec); +} + +timestamp_t Timestamp::FromEpochMsPossiblyInfinite(int64_t ms) { int64_t result; if (!TryMultiplyOperator::Operation(ms, Interval::MICROS_PER_MSEC, result)) { throw ConversionException("Could not convert Timestamp(MS) to Timestamp(US)"); @@ -91894,19 +92710,31 @@ timestamp_t Timestamp::FromEpochMs(int64_t ms) { return timestamp_t(result); } +timestamp_t Timestamp::FromEpochMs(int64_t ms) { + D_ASSERT(Timestamp::IsFinite(timestamp_t(ms))); + return FromEpochMsPossiblyInfinite(ms); +} + timestamp_t Timestamp::FromEpochMicroSeconds(int64_t micros) { return timestamp_t(micros); } -timestamp_t Timestamp::FromEpochNanoSeconds(int64_t ns) { +timestamp_t Timestamp::FromEpochNanoSecondsPossiblyInfinite(int64_t ns) { return timestamp_t(ns / 1000); } +timestamp_t Timestamp::FromEpochNanoSeconds(int64_t ns) { + D_ASSERT(Timestamp::IsFinite(timestamp_t(ns))); + return FromEpochNanoSecondsPossiblyInfinite(ns); +} + int64_t Timestamp::GetEpochSeconds(timestamp_t timestamp) { + D_ASSERT(Timestamp::IsFinite(timestamp)); return timestamp.value / Interval::MICROS_PER_SEC; } int64_t Timestamp::GetEpochMs(timestamp_t timestamp) { + D_ASSERT(Timestamp::IsFinite(timestamp)); return timestamp.value / Interval::MICROS_PER_MSEC; } @@ -91914,10 +92742,19 @@ int64_t Timestamp::GetEpochMicroSeconds(timestamp_t timestamp) { return timestamp.value; } +bool Timestamp::TryGetEpochNanoSeconds(timestamp_t timestamp, int64_t &result) { + constexpr static const int64_t NANOSECONDS_IN_MICROSECOND = 1000; + D_ASSERT(Timestamp::IsFinite(timestamp)); + if (!TryMultiplyOperator::Operation(timestamp.value, NANOSECONDS_IN_MICROSECOND, result)) { + return false; + } + return true; +} + int64_t Timestamp::GetEpochNanoSeconds(timestamp_t timestamp) { int64_t result; - int64_t ns_in_us = 1000; - if (!TryMultiplyOperator::Operation(timestamp.value, ns_in_us, result)) { + D_ASSERT(Timestamp::IsFinite(timestamp)); + if (!TryGetEpochNanoSeconds(timestamp, result)) { throw ConversionException("Could not convert Timestamp(US) to Timestamp(NS)"); } return result; @@ -91940,6 +92777,7 @@ double Timestamp::GetJulianDay(timestamp_t timestamp) { + #include #include @@ -91997,7 +92835,7 @@ string Uhugeint::ToString(uhugeint_t input) { break; } input = Uhugeint::DivMod(input, 10, remainder); - result = string(1, '0' + remainder.lower) + result; // NOLINT + result = string(1, UnsafeNumericCast('0' + remainder.lower)) + result; // NOLINT } if (result.empty()) { // value is zero @@ -92365,7 +93203,7 @@ uhugeint_t UhugeintConvertInteger(DST input) { template <> bool Uhugeint::TryConvert(const char *value, uhugeint_t &result) { auto len = strlen(value); - string_t string_val(value, len); + string_t string_val(value, UnsafeNumericCast(len)); return TryCast::Operation(string_val, result, true); } @@ -92764,6 +93602,17 @@ void UUID::ToString(hugeint_t input, char *buf) { byte_to_hex(input.lower & 0xFF, buf, pos); } +hugeint_t UUID::FromUHugeint(uhugeint_t input) { + hugeint_t result; + result.lower = input.lower; + if (input.upper > uint64_t(NumericLimits::Maximum())) { + result.upper = int64_t(input.upper - uint64_t(NumericLimits::Maximum()) - 1); + } else { + result.upper = int64_t(input.upper) - NumericLimits::Maximum() - 1; + } + return result; +} + hugeint_t UUID::GenerateRandomUUID(RandomEngine &engine) { uint8_t bytes[16]; for (int i = 0; i < 16; i += 4) { @@ -92809,6 +93658,7 @@ hugeint_t UUID::GenerateRandomUUID() { + namespace duckdb { ValidityData::ValidityData(idx_t count) : TemplatedValidityData(count) { @@ -93001,13 +93851,13 @@ void ValidityMask::Write(WriteStream &writer, idx_t count) { // serialize (in)valid value indexes as [COUNT][V0][V1][...][VN] auto flag = serialize_valid ? ValiditySerialization::VALID_VALUES : ValiditySerialization::INVALID_VALUES; writer.Write(flag); - writer.Write(MinValue(valid_values, invalid_values)); + writer.Write(NumericCast(MinValue(valid_values, invalid_values))); for (idx_t i = 0; i < count; i++) { if (RowIsValid(i) == serialize_valid) { if (need_u32) { - writer.Write(i); + writer.Write(UnsafeNumericCast(i)); } else { - writer.Write(i); + writer.Write(UnsafeNumericCast(i)); } } } @@ -93177,6 +94027,7 @@ struct GetCastFunctionInput { } optional_ptr context; + optional_idx query_location; }; struct BindCastFunction { @@ -93326,6 +94177,10 @@ Value::Value(int32_t val) : type_(LogicalType::INTEGER), is_null(false) { value_.integer = val; } +Value::Value(bool val) : type_(LogicalType::BOOLEAN), is_null(false) { + value_.boolean = val; +} + Value::Value(int64_t val) : type_(LogicalType::BIGINT), is_null(false) { value_.bigint = val; } @@ -93723,10 +94578,10 @@ Value Value::DECIMAL(int64_t value, uint8_t width, uint8_t scale) { Value result(decimal_type); switch (decimal_type.InternalType()) { case PhysicalType::INT16: - result.value_.smallint = value; + result.value_.smallint = NumericCast(value); break; case PhysicalType::INT32: - result.value_.integer = value; + result.value_.integer = NumericCast(value); break; case PhysicalType::INT64: result.value_.bigint = value; @@ -94013,6 +94868,13 @@ Value Value::BLOB(const string &data) { return result; } +Value Value::AGGREGATE_STATE(const LogicalType &type, const_data_ptr_t data, idx_t len) { // NOLINT + Value result(type); + result.is_null = false; + result.value_info_ = make_shared(string(const_char_ptr_cast(data), len)); + return result; +} + Value Value::BIT(const_data_ptr_t data, idx_t len) { Value result(LogicalType::BIT); result.is_null = false; @@ -94032,13 +94894,13 @@ Value Value::ENUM(uint64_t value, const LogicalType &original_type) { Value result(original_type); switch (original_type.InternalType()) { case PhysicalType::UINT8: - result.value_.utinyint = value; + result.value_.utinyint = NumericCast(value); break; case PhysicalType::UINT16: - result.value_.usmallint = value; + result.value_.usmallint = NumericCast(value); break; case PhysicalType::UINT32: - result.value_.uinteger = value; + result.value_.uinteger = NumericCast(value); break; default: throw InternalException("Incorrect Physical Type for ENUM"); @@ -94406,7 +95268,7 @@ Value Value::Numeric(const LogicalType &type, int64_t value) { return Value::POINTER(value); case LogicalTypeId::DATE: D_ASSERT(value >= NumericLimits::Minimum() && value <= NumericLimits::Maximum()); - return Value::DATE(date_t(value)); + return Value::DATE(date_t(NumericCast(value))); case LogicalTypeId::TIME: return Value::TIME(dtime_t(value)); case LogicalTypeId::TIMESTAMP: @@ -95374,6 +96236,7 @@ void ListContainsOrPosition(DataChunk &args, Vector &result) { break; case PhysicalType::STRUCT: case PhysicalType::LIST: + case PhysicalType::ARRAY: TemplatedContainsOrPosition(args, result, true); break; default: @@ -95415,7 +96278,7 @@ struct PositionFunctor { return 0; } static inline int32_t UpdateResultEntries(idx_t child_idx) { - return child_idx + 1; + return UnsafeNumericCast(child_idx + 1); } }; @@ -95514,6 +96377,32 @@ struct StructExtractFun { namespace duckdb { +UnifiedVectorFormat::UnifiedVectorFormat() : sel(nullptr), data(nullptr) { +} + +UnifiedVectorFormat::UnifiedVectorFormat(UnifiedVectorFormat &&other) noexcept { + bool refers_to_self = other.sel == &other.owned_sel; + std::swap(sel, other.sel); + std::swap(data, other.data); + std::swap(validity, other.validity); + std::swap(owned_sel, other.owned_sel); + if (refers_to_self) { + sel = &owned_sel; + } +} + +UnifiedVectorFormat &UnifiedVectorFormat::operator=(UnifiedVectorFormat &&other) noexcept { + bool refers_to_self = other.sel == &other.owned_sel; + std::swap(sel, other.sel); + std::swap(data, other.data); + std::swap(validity, other.validity); + std::swap(owned_sel, other.owned_sel); + if (refers_to_self) { + sel = &owned_sel; + } + return *this; +} + Vector::Vector(LogicalType type_p, bool create_data, bool zero_data, idx_t capacity) : vector_type(VectorType::FLAT_VECTOR), type(std::move(type_p)), data(nullptr), validity(capacity) { if (create_data) { @@ -95631,11 +96520,22 @@ void Vector::ResetFromCache(const VectorCache &cache) { } void Vector::Slice(const Vector &other, idx_t offset, idx_t end) { + D_ASSERT(end >= offset); if (other.GetVectorType() == VectorType::CONSTANT_VECTOR) { Reference(other); return; } - D_ASSERT(other.GetVectorType() == VectorType::FLAT_VECTOR); + if (other.GetVectorType() != VectorType::FLAT_VECTOR) { + // we can slice the data directly only for flat vectors + // for non-flat vectors slice using a selection vector instead + idx_t count = end - offset; + SelectionVector sel(count); + for (idx_t i = 0; i < count; i++) { + sel.set_index(i, offset + i); + } + Slice(other, sel, count); + return; + } auto internal_type = GetType().InternalType(); if (internal_type == PhysicalType::STRUCT) { @@ -96111,11 +97011,14 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) { auto str = reinterpret_cast(data)[index]; return Value(str.GetString()); } - case LogicalTypeId::AGGREGATE_STATE: case LogicalTypeId::BLOB: { auto str = reinterpret_cast(data)[index]; return Value::BLOB(const_data_ptr_cast(str.GetData()), str.GetSize()); } + case LogicalTypeId::AGGREGATE_STATE: { + auto str = reinterpret_cast(data)[index]; + return Value::AGGREGATE_STATE(vector->GetType(), const_data_ptr_cast(str.GetData()), str.GetSize()); + } case LogicalTypeId::BIT: { auto str = reinterpret_cast(data)[index]; return Value::BIT(const_data_ptr_cast(str.GetData()), str.GetSize()); @@ -96130,10 +97033,16 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) { return Value::MAP(ListType::GetChildType(type), std::move(children)); } case LogicalTypeId::UNION: { - auto tag = UnionVector::GetTag(*vector, index); - auto value = UnionVector::GetMember(*vector, tag).GetValue(index); - auto members = UnionType::CopyMemberTypes(type); - return Value::UNION(members, tag, std::move(value)); + // Remember to pass the original index_p here so we dont slice twice when looking up the tag + // in case this is a dictionary vector + union_tag_t tag; + if (UnionVector::TryGetTag(*vector, index_p, tag)) { + auto value = UnionVector::GetMember(*vector, tag).GetValue(index_p); + auto members = UnionType::CopyMemberTypes(type); + return Value::UNION(members, tag, std::move(value)); + } else { + return Value(vector->GetType()); + } } case LogicalTypeId::STRUCT: { // we can derive the value schema from the vector schema @@ -96318,7 +97227,7 @@ void Vector::Flatten(idx_t count) { } data = buffer->GetData(); vector_type = VectorType::FLAT_VECTOR; - if (is_null) { + if (is_null && GetType().InternalType() != PhysicalType::ARRAY) { // constant NULL, set nullmask validity.EnsureWritable(); validity.SetAllInvalid(count); @@ -96376,15 +97285,20 @@ void Vector::Flatten(idx_t count) { break; } case PhysicalType::ARRAY: { - auto &child = ArrayVector::GetEntry(*this); + auto &original_child = ArrayVector::GetEntry(*this); auto array_size = ArrayType::GetSize(GetType()); - auto flattened_buffer = make_uniq(GetType(), count); auto &new_child = flattened_buffer->GetChild(); - // Make sure to initialize a validity mask for the new child vector with the correct size - if (!child.validity.AllValid()) { - new_child.validity.Initialize(array_size * count); + // Fast path: The array is a constant null + if (is_null) { + // Invalidate the parent array + validity.SetAllInvalid(count); + // Also invalidate the new child array + new_child.validity.SetAllInvalid(count * array_size); + // Attach the flattened buffer and return + auxiliary = shared_ptr(flattened_buffer.release()); + return; } // Now we need to "unpack" the child vector. @@ -96396,7 +97310,8 @@ void Vector::Flatten(idx_t count) { // | 2 | // ... - child.Flatten(count * array_size); + auto child_vec = make_uniq(original_child); + child_vec->Flatten(count * array_size); // Create a selection vector SelectionVector sel(count * array_size); @@ -96404,7 +97319,7 @@ void Vector::Flatten(idx_t count) { for (idx_t elem_idx = 0; elem_idx < array_size; elem_idx++) { auto position = array_idx * array_size + elem_idx; // Broadcast the validity - if (FlatVector::IsNull(child, elem_idx)) { + if (FlatVector::IsNull(*child_vec, elem_idx)) { FlatVector::SetNull(new_child, position, true); } sel.set_index(position, elem_idx); @@ -96412,7 +97327,7 @@ void Vector::Flatten(idx_t count) { } // Copy over the data to the new buffer - VectorOperations::Copy(child, new_child, sel, count * array_size, 0, 0); + VectorOperations::Copy(*child_vec, new_child, sel, count * array_size, 0, 0); auxiliary = shared_ptr(flattened_buffer.release()); } break; @@ -96456,7 +97371,7 @@ void Vector::Flatten(const SelectionVector &sel, idx_t count) { break; case VectorType::FSST_VECTOR: { // create a new flat vector of this type - Vector other(GetType()); + Vector other(GetType(), count); // copy the data of this vector to the other vector, removing compression and selection vector in the process VectorOperations::Copy(*this, other, sel, count, 0, 0); // create a reference to the data in the other vector @@ -96554,6 +97469,7 @@ void Vector::Sequence(int64_t start, int64_t increment, idx_t count) { auxiliary.reset(); } +// FIXME: This should ideally be const void Vector::Serialize(Serializer &serializer, idx_t count) { auto &logical_type = GetType(); @@ -96624,9 +97540,11 @@ void Vector::Serialize(Serializer &serializer, idx_t count) { break; } case PhysicalType::ARRAY: { - Flatten(count); - auto &child = ArrayVector::GetEntry(*this); - auto array_size = ArrayType::GetSize(type); + Vector serialized_vector(*this); + serialized_vector.Flatten(count); + + auto &child = ArrayVector::GetEntry(serialized_vector); + auto array_size = ArrayType::GetSize(serialized_vector.GetType()); auto child_size = array_size * count; serializer.WriteProperty(103, "array_size", array_size); serializer.WriteObject(104, "child", [&](Serializer &object) { child.Serialize(object, child_size); }); @@ -97009,6 +97927,94 @@ void Vector::Verify(idx_t count) { Verify(*this, *flat_sel, count); } +void Vector::DebugTransformToDictionary(Vector &vector, idx_t count) { + if (vector.GetVectorType() != VectorType::FLAT_VECTOR) { + // only supported for flat vectors currently + return; + } + // convert vector to dictionary vector + // first create an inverted vector of twice the size with NULL values every other value + // i.e. [1, 2, 3] is converted into [NULL, 3, NULL, 2, NULL, 1] + idx_t verify_count = count * 2; + SelectionVector inverted_sel(verify_count); + idx_t offset = 0; + for (idx_t i = 0; i < count; i++) { + idx_t current_index = count - i - 1; + inverted_sel.set_index(offset++, current_index); + inverted_sel.set_index(offset++, current_index); + } + Vector inverted_vector(vector, inverted_sel, verify_count); + inverted_vector.Flatten(verify_count); + // now insert the NULL values at every other position + for (idx_t i = 0; i < count; i++) { + FlatVector::SetNull(inverted_vector, i * 2, true); + } + // construct the selection vector pointing towards the original values + // we start at the back, (verify_count - 1) and move backwards + SelectionVector original_sel(count); + offset = 0; + for (idx_t i = 0; i < count; i++) { + original_sel.set_index(offset++, verify_count - 1 - i * 2); + } + // now slice the inverted vector with the inverted selection vector + vector.Slice(inverted_vector, original_sel, count); + vector.Verify(count); +} + +void Vector::DebugShuffleNestedVector(Vector &vector, idx_t count) { + switch (vector.GetType().id()) { + case LogicalTypeId::STRUCT: { + auto &entries = StructVector::GetEntries(vector); + // recurse into child elements + for (auto &entry : entries) { + Vector::DebugShuffleNestedVector(*entry, count); + } + break; + } + case LogicalTypeId::LIST: { + if (vector.GetVectorType() != VectorType::FLAT_VECTOR) { + break; + } + auto list_entries = FlatVector::GetData(vector); + idx_t child_count = 0; + for (idx_t r = 0; r < count; r++) { + if (FlatVector::IsNull(vector, r)) { + continue; + } + child_count += list_entries[r].length; + } + if (child_count == 0) { + break; + } + auto &child_vector = ListVector::GetEntry(vector); + // reverse the order of all lists + SelectionVector child_sel(child_count); + idx_t position = child_count; + for (idx_t r = 0; r < count; r++) { + if (FlatVector::IsNull(vector, r)) { + continue; + } + // move this list to the back + position -= list_entries[r].length; + for (idx_t k = 0; k < list_entries[r].length; k++) { + child_sel.set_index(position + k, list_entries[r].offset + k); + } + // adjust the offset to this new position + list_entries[r].offset = position; + } + child_vector.Slice(child_sel, child_count); + child_vector.Flatten(child_count); + ListVector::SetListSize(vector, child_count); + + // recurse into child elements + Vector::DebugShuffleNestedVector(child_vector, child_count); + break; + } + default: + break; + } +} + //===--------------------------------------------------------------------===// // FlatVector //===--------------------------------------------------------------------===// @@ -97016,7 +98022,7 @@ 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 &type = vector.GetType(); auto internal_type = type.InternalType(); if (internal_type == PhysicalType::STRUCT) { // set all child entries to null as well @@ -97027,7 +98033,6 @@ void FlatVector::SetNull(Vector &vector, idx_t idx, bool is_null) { } else if (internal_type == PhysicalType::ARRAY) { // set the child element in the array to null as well auto &child = ArrayVector::GetEntry(vector); - D_ASSERT(child.GetVectorType() == VectorType::FLAT_VECTOR); auto array_size = ArrayType::GetSize(type); auto child_offset = idx * array_size; for (idx_t i = 0; i < array_size; i++) { @@ -97116,8 +98121,8 @@ void ConstantVector::Reference(Vector &vector, Vector &source, idx_t position, i case PhysicalType::ARRAY: { UnifiedVectorFormat vdata; source.ToUnifiedFormat(count, vdata); - - if (!vdata.validity.RowIsValid(position)) { + auto source_idx = vdata.sel->get_index(position); + if (!vdata.validity.RowIsValid(source_idx)) { // list is null: create null value Value null_value(source_type); vector.Reference(null_value); @@ -97133,7 +98138,7 @@ void ConstantVector::Reference(Vector &vector, Vector &source, idx_t position, i auto array_size = ArrayType::GetSize(source_type); SelectionVector sel(array_size); for (idx_t i = 0; i < array_size; i++) { - sel.set_index(i, array_size * position + i); + sel.set_index(i, array_size * source_idx + i); } target_child.Slice(sel, array_size); target_child.Flatten(array_size); // since its constant we only have to flatten this much @@ -97178,19 +98183,19 @@ void ConstantVector::Reference(Vector &vector, Vector &source, idx_t position, i // StringVector //===--------------------------------------------------------------------===// string_t StringVector::AddString(Vector &vector, const char *data, idx_t len) { - return StringVector::AddString(vector, string_t(data, len)); + return StringVector::AddString(vector, string_t(data, UnsafeNumericCast(len))); } string_t StringVector::AddStringOrBlob(Vector &vector, const char *data, idx_t len) { - return StringVector::AddStringOrBlob(vector, string_t(data, len)); + return StringVector::AddStringOrBlob(vector, string_t(data, UnsafeNumericCast(len))); } string_t StringVector::AddString(Vector &vector, const char *data) { - return StringVector::AddString(vector, string_t(data, strlen(data))); + return StringVector::AddString(vector, string_t(data, UnsafeNumericCast(strlen(data)))); } string_t StringVector::AddString(Vector &vector, const string &data) { - return StringVector::AddString(vector, string_t(data.c_str(), data.size())); + return StringVector::AddString(vector, string_t(data.c_str(), UnsafeNumericCast(data.size()))); } string_t StringVector::AddString(Vector &vector, string_t data) { @@ -97224,7 +98229,7 @@ string_t StringVector::AddStringOrBlob(Vector &vector, string_t data) { string_t StringVector::EmptyString(Vector &vector, idx_t len) { D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR); if (len <= string_t::INLINE_LENGTH) { - return string_t(len); + return string_t(UnsafeNumericCast(len)); } if (!vector.auxiliary) { vector.auxiliary = make_buffer(); @@ -97271,7 +98276,7 @@ void StringVector::AddHeapReference(Vector &vector, Vector &other) { // FSSTVector //===--------------------------------------------------------------------===// string_t FSSTVector::AddCompressedString(Vector &vector, const char *data, idx_t len) { - return FSSTVector::AddCompressedString(vector, string_t(data, len)); + return FSSTVector::AddCompressedString(vector, string_t(data, UnsafeNumericCast(len))); } string_t FSSTVector::AddCompressedString(Vector &vector, string_t data) { @@ -97376,60 +98381,76 @@ const Vector &MapVector::GetValues(const Vector &vector) { } MapInvalidReason MapVector::CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel) { + D_ASSERT(map.GetType().id() == LogicalTypeId::MAP); - UnifiedVectorFormat map_vdata; - map.ToUnifiedFormat(count, map_vdata); - auto &map_validity = map_vdata.validity; + // unify the MAP vector, which is a physical LIST vector + UnifiedVectorFormat map_data; + map.ToUnifiedFormat(count, map_data); + auto map_entries = UnifiedVectorFormat::GetDataNoConst(map_data); + auto maps_length = ListVector::GetListSize(map); - auto list_data = ListVector::GetData(map); + // unify the child vector containing the keys auto &keys = MapVector::GetKeys(map); - UnifiedVectorFormat key_vdata; - keys.ToUnifiedFormat(count, key_vdata); - auto &key_validity = key_vdata.validity; + UnifiedVectorFormat key_data; + keys.ToUnifiedFormat(maps_length, key_data); - for (idx_t row = 0; row < count; row++) { - auto mapped_row = sel.get_index(row); - auto map_idx = map_vdata.sel->get_index(mapped_row); - // map is allowed to be NULL - if (!map_validity.RowIsValid(map_idx)) { + for (idx_t row_idx = 0; row_idx < count; row_idx++) { + + auto mapped_row = sel.get_index(row_idx); + auto map_idx = map_data.sel->get_index(mapped_row); + + if (!map_data.validity.RowIsValid(map_idx)) { continue; } + value_set_t unique_keys; - for (idx_t i = 0; i < list_data[map_idx].length; i++) { - auto index = list_data[map_idx].offset + i; - index = key_vdata.sel->get_index(index); - if (!key_validity.RowIsValid(index)) { + auto length = map_entries[map_idx].length; + auto offset = map_entries[map_idx].offset; + + for (idx_t child_idx = 0; child_idx < length; child_idx++) { + auto key_idx = key_data.sel->get_index(offset + child_idx); + + if (!key_data.validity.RowIsValid(key_idx)) { return MapInvalidReason::NULL_KEY; } - auto value = keys.GetValue(index); - auto result = unique_keys.insert(value); - if (!result.second) { + + auto value = keys.GetValue(key_idx); + auto unique = unique_keys.insert(value).second; + if (!unique) { return MapInvalidReason::DUPLICATE_KEY; } } } + return MapInvalidReason::VALID; } void MapVector::MapConversionVerify(Vector &vector, idx_t count) { - auto valid_check = MapVector::CheckMapValidity(vector, count); - switch (valid_check) { + auto reason = MapVector::CheckMapValidity(vector, count); + EvalMapInvalidReason(reason); +} + +void MapVector::EvalMapInvalidReason(MapInvalidReason reason) { + switch (reason) { case MapInvalidReason::VALID: - break; - case MapInvalidReason::DUPLICATE_KEY: { - throw InvalidInputException("Map keys have to be unique"); - } - case MapInvalidReason::NULL_KEY: { - throw InvalidInputException("Map keys can not be NULL"); - } - case MapInvalidReason::NULL_KEY_LIST: { - throw InvalidInputException("The list of map keys is not allowed to be NULL"); - } - default: { + return; + case MapInvalidReason::DUPLICATE_KEY: + throw InvalidInputException("Map keys must be unique."); + case MapInvalidReason::NULL_KEY: + throw InvalidInputException("Map keys can not be NULL."); + case MapInvalidReason::NULL_KEY_LIST: + throw InvalidInputException("The list of map keys must not be NULL."); + case MapInvalidReason::NULL_VALUE_LIST: + throw InvalidInputException("The list of map values must not be NULL."); + case MapInvalidReason::NOT_ALIGNED: + throw InvalidInputException("The map key list does not align with the map value list."); + case MapInvalidReason::INVALID_PARAMS: + throw InvalidInputException("Invalid map argument(s). Valid map arguments are a list of key-value pairs (MAP " + "{'key1': 'val1', ...}), two lists (MAP ([1, 2], [10, 11])), or no arguments."); + default: throw InternalException("MapInvalidReason not implemented"); } - } } //===--------------------------------------------------------------------===// @@ -97716,17 +98737,34 @@ void UnionVector::SetToMember(Vector &union_vector, union_tag_t tag, Vector &mem } } -union_tag_t UnionVector::GetTag(const Vector &vector, idx_t index) { +bool UnionVector::TryGetTag(const Vector &vector, idx_t index, union_tag_t &result) { // the tag vector is always the first struct child. auto &tag_vector = *StructVector::GetEntries(vector)[0]; if (tag_vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) { auto &child = DictionaryVector::Child(tag_vector); - return FlatVector::GetData(child)[index]; + auto &dict_sel = DictionaryVector::SelVector(tag_vector); + auto mapped_idx = dict_sel.get_index(index); + if (FlatVector::IsNull(child, mapped_idx)) { + return false; + } else { + result = FlatVector::GetData(child)[mapped_idx]; + return true; + } } if (tag_vector.GetVectorType() == VectorType::CONSTANT_VECTOR) { - return ConstantVector::GetData(tag_vector)[0]; + if (ConstantVector::IsNull(tag_vector)) { + return false; + } else { + result = ConstantVector::GetData(tag_vector)[0]; + return true; + } + } + if (FlatVector::IsNull(tag_vector, index)) { + return false; + } else { + result = FlatVector::GetData(tag_vector)[index]; + return true; } - return FlatVector::GetData(tag_vector)[index]; } //! Raw selection vector passed in (not merged with any other selection vectors) @@ -98155,6 +99193,7 @@ const sel_t ConstantVector::ZERO_VECTOR[STANDARD_VECTOR_SIZE] = {0}; + //===----------------------------------------------------------------------===// @@ -98831,7 +99870,7 @@ static LogicalType DecimalSizeCheck(const LogicalType &left, const LogicalType & D_ASSERT(other_scale == 0); const auto effective_width = width - scale; if (other_width > effective_width) { - auto new_width = other_width + scale; + auto new_width = NumericCast(other_width + scale); //! Cap the width at max, if an actual value exceeds this, an exception will be thrown later if (new_width > DecimalType::MaxWidth()) { new_width = DecimalType::MaxWidth(); @@ -98983,13 +100022,14 @@ static bool CombineEqualTypes(const LogicalType &left, const LogicalType &right, // using the max of these of the two types gives us the new decimal size auto extra_width_left = DecimalType::GetWidth(left) - DecimalType::GetScale(left); auto extra_width_right = DecimalType::GetWidth(right) - DecimalType::GetScale(right); - auto extra_width = MaxValue(extra_width_left, extra_width_right); + auto extra_width = + MaxValue(NumericCast(extra_width_left), NumericCast(extra_width_right)); auto scale = MaxValue(DecimalType::GetScale(left), DecimalType::GetScale(right)); - auto width = extra_width + scale; + auto width = NumericCast(extra_width + scale); if (width > DecimalType::MaxWidth()) { // if the resulting decimal does not fit, we truncate the scale width = DecimalType::MaxWidth(); - scale = width - extra_width; + scale = NumericCast(width - extra_width); } result = LogicalType::DECIMAL(width, scale); return true; @@ -99327,7 +100367,7 @@ uint8_t DecimalType::MaxWidth() { return DecimalWidth::max; } -LogicalType LogicalType::DECIMAL(int width, int scale) { +LogicalType LogicalType::DECIMAL(uint8_t width, uint8_t scale) { D_ASSERT(width >= scale); auto type_info = make_shared(width, scale); return LogicalType(LogicalTypeId::DECIMAL, std::move(type_info)); @@ -100511,6 +101551,7 @@ void VectorOperations::LessThan(Vector &left, Vector &right, Vector &result, idx + namespace duckdb { template @@ -100570,7 +101611,7 @@ void TemplatedGenerateSequence(Vector &result, idx_t count, const SelectionVecto auto value = (T)start; for (idx_t i = 0; i < count; i++) { auto idx = sel.get_index(i); - result_data[idx] = value + increment * idx; + result_data[idx] = UnsafeNumericCast(value + increment * idx); } } @@ -101823,14 +102864,14 @@ void VectorOperations::AddInPlace(Vector &input, int64_t right, idx_t count) { namespace duckdb { bool VectorOperations::TryCast(CastFunctionSet &set, GetCastFunctionInput &input, Vector &source, Vector &result, - idx_t count, string *error_message, bool strict) { + idx_t count, string *error_message, bool strict, const bool nullify_parent) { auto cast_function = set.GetCastFunction(source.GetType(), result.GetType(), input); unique_ptr local_state; if (cast_function.init_local_state) { CastLocalStateParameters lparameters(input.context, cast_function.cast_data); local_state = cast_function.init_local_state(lparameters); } - CastParameters parameters(cast_function.cast_data.get(), strict, error_message, local_state.get()); + CastParameters parameters(cast_function.cast_data.get(), strict, error_message, local_state.get(), nullify_parent); return cast_function.function(source, result, count, parameters); } @@ -101845,11 +102886,11 @@ void VectorOperations::DefaultCast(Vector &source, Vector &result, idx_t count, } bool VectorOperations::TryCast(ClientContext &context, Vector &source, Vector &result, idx_t count, - string *error_message, bool strict) { + string *error_message, bool strict, const bool nullify_parent) { auto &config = DBConfig::GetConfig(context); auto &set = config.GetCastFunctions(); GetCastFunctionInput get_input(context); - return VectorOperations::TryCast(set, get_input, source, result, count, error_message, strict); + return VectorOperations::TryCast(set, get_input, source, result, count, error_message, strict, nullify_parent); } void VectorOperations::Cast(ClientContext &context, Vector &source, Vector &result, idx_t count, bool strict) { @@ -102062,11 +103103,11 @@ void VectorOperations::Copy(const Vector &source_p, Vector &target, const Select auto array_size = ArrayType::GetSize(source->GetType()); // Create a selection vector for the child elements - SelectionVector child_sel(copy_count * array_size); + SelectionVector child_sel(source_count * array_size); for (idx_t i = 0; i < copy_count; i++) { auto source_idx = sel->get_index(source_offset + i); for (idx_t j = 0; j < array_size; j++) { - child_sel.set_index(i * array_size + j, source_idx * array_size + j); + child_sel.set_index((source_offset * array_size) + (i * array_size + j), source_idx * array_size + j); } } VectorOperations::Copy(source_child, target_child, child_sel, source_count * array_size, @@ -102334,13 +103375,18 @@ template static inline void ArrayLoopHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) { auto hdata = FlatVector::GetData(hashes); + if (input.GetVectorType() != VectorType::CONSTANT_VECTOR || input.GetVectorType() != VectorType::FLAT_VECTOR) { + input.Flatten(count); + } + UnifiedVectorFormat idata; input.ToUnifiedFormat(count, idata); // Hash the children into a temporary auto &child = ArrayVector::GetEntry(input); auto array_size = ArrayType::GetSize(input.GetType()); - auto child_count = array_size * count; + auto is_constant = input.GetVectorType() == VectorType::CONSTANT_VECTOR; + auto child_count = array_size * (is_constant ? 1 : count); Vector child_hashes(LogicalType::HASH, child_count); if (child_count > 0) { @@ -102349,12 +103395,18 @@ static inline void ArrayLoopHash(Vector &input, Vector &hashes, const SelectionV } auto chdata = FlatVector::GetData(child_hashes); - // Combine hashes for every array - // TODO: Branch on FIRST_HASH and HAS_RSEL - for (idx_t i = 0; i < count; i++) { - for (idx_t j = i * array_size; j < (i + 1) * array_size; j++) { - hdata[i] = CombineHashScalar(hdata[i], chdata[j]); + for (idx_t i = 0; i < count; ++i) { + const auto ridx = HAS_RSEL ? rsel->get_index(i) : i; + const auto lidx = idata.sel->get_index(ridx); + const auto offset = lidx * array_size; + if (idata.validity.RowIsValid(lidx)) { + for (idx_t j = 0; j < array_size; j++) { + hdata[ridx] = CombineHashScalar(hdata[ridx], chdata[offset + j]); + } + } else if (FIRST_HASH) { + hdata[ridx] = HashOp::NULL_HASH; } + // Empty or NULL non-first elements have no effect. } } @@ -104307,6 +105359,7 @@ AggregateFunctionSet ApproxCountDistinctFun::GetFunctions() { + namespace duckdb { struct ArgMinMaxStateBase { @@ -104370,7 +105423,7 @@ void ArgMinMaxStateBase::AssignValue(string_t &target, string_t new_value) { auto ptr = new char[len]; memcpy(ptr, new_value.GetData(), len); - target = string_t(ptr, len); + target = string_t(ptr, UnsafeNumericCast(len)); } } @@ -104490,7 +105543,7 @@ struct VectorArgMinMaxBase : ArgMinMaxBase { } state.arg_null = arg_null; if (!arg_null) { - sel_t selv = idx; + sel_t selv = UnsafeNumericCast(idx); SelectionVector sel(&selv); VectorOperations::Copy(arg, *state.arg, sel, 1, 0, 0); } @@ -104584,6 +105637,8 @@ AggregateFunction GetVectorArgMinMaxFunctionBy(const LogicalType &by_type, const return GetVectorArgMinMaxFunctionInternal(by_type, type); case PhysicalType::INT64: return GetVectorArgMinMaxFunctionInternal(by_type, type); + case PhysicalType::INT128: + return GetVectorArgMinMaxFunctionInternal(by_type, type); case PhysicalType::DOUBLE: return GetVectorArgMinMaxFunctionInternal(by_type, type); case PhysicalType::VARCHAR: @@ -104594,9 +105649,9 @@ AggregateFunction GetVectorArgMinMaxFunctionBy(const LogicalType &by_type, const } static const vector ArgMaxByTypes() { - vector types = {LogicalType::INTEGER, LogicalType::BIGINT, LogicalType::DOUBLE, - LogicalType::VARCHAR, LogicalType::DATE, LogicalType::TIMESTAMP, - LogicalType::TIMESTAMP_TZ, LogicalType::BLOB}; + vector types = {LogicalType::INTEGER, LogicalType::BIGINT, LogicalType::HUGEINT, + LogicalType::DOUBLE, LogicalType::VARCHAR, LogicalType::DATE, + LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ, LogicalType::BLOB}; return types; } @@ -104628,12 +105683,14 @@ AggregateFunction GetArgMinMaxFunctionBy(const LogicalType &by_type, const Logic return GetArgMinMaxFunctionInternal(by_type, type); case PhysicalType::INT64: return GetArgMinMaxFunctionInternal(by_type, type); + case PhysicalType::INT128: + return GetArgMinMaxFunctionInternal(by_type, type); case PhysicalType::DOUBLE: return GetArgMinMaxFunctionInternal(by_type, type); case PhysicalType::VARCHAR: return GetArgMinMaxFunctionInternal(by_type, type); default: - throw InternalException("Unimplemented arg_min/arg_max aggregate"); + throw InternalException("Unimplemented arg_min/arg_max by aggregate"); } } @@ -104665,6 +105722,25 @@ static unique_ptr BindDecimalArgMinMax(ClientContext &context, Agg vector> &arguments) { auto decimal_type = arguments[0]->return_type; auto by_type = arguments[1]->return_type; + + // To avoid a combinatorial explosion, cast the ordering argument to one from the list + auto by_types = ArgMaxByTypes(); + idx_t best_target = DConstants::INVALID_INDEX; + int64_t lowest_cost = NumericLimits::Maximum(); + for (idx_t i = 0; i < by_types.size(); ++i) { + auto cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(by_type, by_types[i]); + if (cast_cost < 0) { + continue; + } + if (cast_cost < lowest_cost) { + best_target = i; + } + } + + if (best_target != DConstants::INVALID_INDEX) { + by_type = by_types[best_target]; + } + auto name = std::move(function.name); function = GetDecimalArgMinMaxFunction(by_type, decimal_type); function.name = std::move(name); @@ -104872,7 +105948,7 @@ struct BitStringBitwiseOperation : public BitwiseOperation { auto ptr = new char[len]; memcpy(ptr, input.GetData(), len); - state.value = string_t(ptr, len); + state.value = string_t(ptr, UnsafeNumericCast(len)); } } @@ -105018,6 +106094,10 @@ struct BitStringAggOperation { } state.min = bind_agg_data.min.GetValue(); state.max = bind_agg_data.max.GetValue(); + if (state.min > state.max) { + throw InvalidInputException("Invalid explicit bitstring range: Minimum (%s) > maximum (%s)", + NumericHelper::ToString(state.min), NumericHelper::ToString(state.max)); + } idx_t bit_range = GetRange(bind_agg_data.min.GetValue(), bind_agg_data.max.GetValue()); if (bit_range > MAX_BIT_RANGE) { @@ -105026,7 +106106,8 @@ struct BitStringAggOperation { NumericHelper::ToString(state.min), NumericHelper::ToString(state.max)); } idx_t len = Bit::ComputeBitstringLen(bit_range); - auto target = len > string_t::INLINE_LENGTH ? string_t(new char[len], len) : string_t(len); + auto target = len > string_t::INLINE_LENGTH ? string_t(new char[len], UnsafeNumericCast(len)) + : string_t(UnsafeNumericCast(len)); Bit::SetEmptyBitString(target, bit_range); state.value = target; @@ -105049,7 +106130,9 @@ struct BitStringAggOperation { template static idx_t GetRange(INPUT_TYPE min, INPUT_TYPE max) { - D_ASSERT(max >= min); + if (min > max) { + throw InvalidInputException("Invalid explicit bitstring range: Minimum (%d) > maximum (%d)", min, max); + } INPUT_TYPE result; if (!TrySubtractOperator::Operation(max, min, result)) { return NumericLimits::Maximum(); @@ -105090,7 +106173,7 @@ struct BitStringAggOperation { auto len = input.GetSize(); auto ptr = new char[len]; memcpy(ptr, input.GetData(), len); - state.value = string_t(ptr, len); + state.value = string_t(ptr, UnsafeNumericCast(len)); } } @@ -105132,7 +106215,7 @@ idx_t BitStringAggOperation::GetRange(hugeint_t min, hugeint_t max) { return NumericLimits::Maximum(); } idx_t range; - if (!Hugeint::TryCast(result + 1, range)) { + if (!Hugeint::TryCast(result + 1, range) || result == NumericLimits::Maximum()) { return NumericLimits::Maximum(); } return range; @@ -105155,7 +106238,7 @@ idx_t BitStringAggOperation::GetRange(uhugeint_t min, uhugeint_t max) { return NumericLimits::Maximum(); } idx_t range; - if (!Uhugeint::TryCast(result + 1, range)) { + if (!Uhugeint::TryCast(result + 1, range) || result == NumericLimits::Maximum()) { return NumericLimits::Maximum(); } return range; @@ -105910,7 +106993,7 @@ struct StringMinMaxBase : public MinMaxBase { auto ptr = new char[len]; memcpy(ptr, input.GetData(), len); - state.value = string_t(ptr, len); + state.value = string_t(ptr, UnsafeNumericCast(len)); } } @@ -106201,7 +107284,7 @@ struct VectorMinMaxBase { state.value = new Vector(input.GetType()); state.value->SetVectorType(VectorType::CONSTANT_VECTOR); } - sel_t selv = idx; + sel_t selv = UnsafeNumericCast(idx); SelectionVector sel(&selv); VectorOperations::Copy(input, *state.value, sel, 1, 0, 0); } @@ -106664,7 +107747,8 @@ struct StringAggFunction { // source is not set: skip combining return; } - PerformOperation(target, string_t(source.dataptr, source.size), aggr_input_data.bind_data); + PerformOperation(target, string_t(source.dataptr, UnsafeNumericCast(source.size)), + aggr_input_data.bind_data); } }; @@ -107477,12 +108561,12 @@ class TDigest { std::vector cumulative_; // return mean of i-th centroid - inline Value mean(int i) const noexcept { + inline Value mean(size_t i) const noexcept { return processed_[i].mean(); } // return weight of i-th centroid - inline Weight weight(int i) const noexcept { + inline Weight weight(size_t i) const noexcept { return processed_[i].weight(); } @@ -107605,7 +108689,7 @@ class TDigest { updateCumulative(); } - inline int checkWeights() { + inline size_t checkWeights() { return checkWeights(processed_, processedWeight_); } @@ -108078,7 +109162,8 @@ struct hash { inline size_t operator()(const duckdb::interval_t &val) const { int64_t months, days, micros; val.Normalize(months, days, micros); - return hash {}(days) ^ hash {}(months) ^ hash {}(micros); + return hash {}(duckdb::UnsafeNumericCast(days)) ^ + hash {}(duckdb::UnsafeNumericCast(months)) ^ hash {}(micros); } }; @@ -111662,12 +112747,6 @@ void HeadNode::dotFileFinalise(std::ostream &os) const { namespace duckdb { -// Hugeint arithmetic -static hugeint_t MultiplyByDouble(const hugeint_t &h, const double &d) { - D_ASSERT(d >= 0 && d <= 1); - return Hugeint::Convert(Hugeint::Cast(h) * d); -} - // Interval arithmetic static interval_t MultiplyByDouble(const interval_t &i, const double &d) { // NOLINT D_ASSERT(d >= 0 && d <= 1); @@ -111830,8 +112909,7 @@ timestamp_t CastInterpolation::Interpolate(const timestamp_t &lo, const double d template <> hugeint_t CastInterpolation::Interpolate(const hugeint_t &lo, const double d, const hugeint_t &hi) { - const hugeint_t delta = hi - lo; - return lo + MultiplyByDouble(delta, d); + return Hugeint::Convert(Interpolate(Hugeint::Cast(lo), d, Hugeint::Cast(hi))); } template <> @@ -112904,7 +113982,7 @@ struct MadAccessor { } inline RESULT_TYPE operator()(const INPUT_TYPE &input) const { - const auto delta = input - median; + const RESULT_TYPE delta = input - UnsafeNumericCast(median); return TryAbsOperator::Operation(delta); } }; @@ -114518,7 +115596,7 @@ struct RegrCountFunction { template static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) { - target = state; + target = static_cast(state); } static bool IgnoreNull() { return true; @@ -116244,6 +117322,15 @@ struct ListInnerProductFunAlias { static constexpr const char *Name = "<#>"; }; +struct UnpivotListFun { + static constexpr const char *Name = "unpivot_list"; + static constexpr const char *Parameters = "any,..."; + static constexpr const char *Description = "Identical to list_value, but generated as part of unpivot for better error messages"; + static constexpr const char *Example = "unpivot_list(4, 5, 6)"; + + static ScalarFunction GetFunction(); +}; + } // namespace duckdb //===----------------------------------------------------------------------===// @@ -117970,6 +119057,7 @@ static StaticFunctionDefinition internal_functions[] = { DUCKDB_SCALAR_FUNCTION(UnionExtractFun), DUCKDB_SCALAR_FUNCTION(UnionTagFun), DUCKDB_SCALAR_FUNCTION(UnionValueFun), + DUCKDB_SCALAR_FUNCTION(UnpivotListFun), DUCKDB_SCALAR_FUNCTION(UUIDFun), DUCKDB_AGGREGATE_FUNCTION(VarPopFun), DUCKDB_AGGREGATE_FUNCTION(VarSampFun), @@ -119004,7 +120092,7 @@ struct GetBitOperator { throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n), NumericHelper::ToString(Bit::BitLength(input) - 1)); } - return Bit::GetBit(input, n); + return UnsafeNumericCast(Bit::GetBit(input, n)); } }; @@ -119048,7 +120136,7 @@ struct BitPositionOperator { if (substring.GetSize() > input.GetSize()) { return 0; } - return Bit::BitPosition(substring, input); + return UnsafeNumericCast(Bit::BitPosition(substring, input)); } }; @@ -119928,7 +121016,7 @@ class MetaTransaction { public: DUCKDB_API static MetaTransaction &Get(ClientContext &context); - timestamp_t GetCurrentTransactionStartTimestamp() { + timestamp_t GetCurrentTransactionStartTimestamp() const { return start_timestamp; } @@ -119945,8 +121033,13 @@ class MetaTransaction { optional_ptr ModifiedDatabase() { return modified_database; } + const vector> &OpenedTransactions() const { + return all_transactions; + } private: + //! Lock to prevent all_transactions and transactions from getting out of sync + mutex lock; //! The set of active transactions for each database reference_map_t> transactions; //! The set of transactions in order of when they were started @@ -120207,22 +121300,30 @@ int64_t DateDiff::MicrosecondsOperator::Operation(timestamp_t startdate, timesta template <> int64_t DateDiff::MillisecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) { + D_ASSERT(Timestamp::IsFinite(startdate)); + D_ASSERT(Timestamp::IsFinite(enddate)); return Timestamp::GetEpochMs(enddate) - Timestamp::GetEpochMs(startdate); } template <> int64_t DateDiff::SecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) { + D_ASSERT(Timestamp::IsFinite(startdate)); + D_ASSERT(Timestamp::IsFinite(enddate)); return Timestamp::GetEpochSeconds(enddate) - Timestamp::GetEpochSeconds(startdate); } template <> int64_t DateDiff::MinutesOperator::Operation(timestamp_t startdate, timestamp_t enddate) { + D_ASSERT(Timestamp::IsFinite(startdate)); + D_ASSERT(Timestamp::IsFinite(enddate)); return Timestamp::GetEpochSeconds(enddate) / Interval::SECS_PER_MINUTE - Timestamp::GetEpochSeconds(startdate) / Interval::SECS_PER_MINUTE; } template <> int64_t DateDiff::HoursOperator::Operation(timestamp_t startdate, timestamp_t enddate) { + D_ASSERT(Timestamp::IsFinite(startdate)); + D_ASSERT(Timestamp::IsFinite(enddate)); return Timestamp::GetEpochSeconds(enddate) / Interval::SECS_PER_HOUR - Timestamp::GetEpochSeconds(startdate) / Interval::SECS_PER_HOUR; } @@ -120840,8 +121941,11 @@ struct DatePart { static void Inverse(DataChunk &input, ExpressionState &state, Vector &result) { D_ASSERT(input.ColumnCount() == 1); - UnaryExecutor::Execute(input.data[0], result, input.size(), - [&](int64_t input) { return Timestamp::FromEpochMs(input); }); + UnaryExecutor::Execute(input.data[0], result, input.size(), [&](int64_t input) { + // milisecond amounts provided to epoch_ms should never be considered infinite + // instead such values will just throw when converted to microseconds + return Timestamp::FromEpochMsPossiblyInfinite(input); + }); } }; @@ -120946,7 +122050,7 @@ struct DatePart { auto time = Time::NormalizeTimeTZ(timetz); date_t date(0); time = Interval::Add(time, interval, date); - auto offset = interval.micros / Interval::MICROS_PER_SEC; + auto offset = UnsafeNumericCast(interval.micros / Interval::MICROS_PER_SEC); return TR(time, offset); } @@ -121444,11 +122548,13 @@ int64_t DatePart::YearWeekOperator::Operation(dtime_tz_t input) { template <> int64_t DatePart::EpochNanosecondsOperator::Operation(timestamp_t input) { + D_ASSERT(Timestamp::IsFinite(input)); return Timestamp::GetEpochNanoSeconds(input); } template <> int64_t DatePart::EpochNanosecondsOperator::Operation(date_t input) { + D_ASSERT(Date::IsFinite(input)); return Date::EpochNanoseconds(input); } @@ -121477,6 +122583,12 @@ int64_t DatePart::EpochMicrosecondsOperator::Operation(interval_t input) { return Interval::GetMicro(input); } +template <> +int64_t DatePart::EpochMillisOperator::Operation(timestamp_t input) { + D_ASSERT(Timestamp::IsFinite(input)); + return Timestamp::GetEpochMs(input); +} + template <> int64_t DatePart::EpochMicrosecondsOperator::Operation(dtime_t input) { return input.micros; @@ -121509,6 +122621,7 @@ int64_t DatePart::EpochMillisOperator::Operation(dtime_tz_t input) { template <> int64_t DatePart::MicrosecondsOperator::Operation(timestamp_t input) { + D_ASSERT(Timestamp::IsFinite(input)); auto time = Timestamp::GetTime(input); // remove everything but the second & microsecond part return time.micros % Interval::MICROS_PER_MINUTE; @@ -121533,6 +122646,7 @@ int64_t DatePart::MicrosecondsOperator::Operation(dtime_tz_t input) { template <> int64_t DatePart::MillisecondsOperator::Operation(timestamp_t input) { + D_ASSERT(Timestamp::IsFinite(input)); return MicrosecondsOperator::Operation(input) / Interval::MICROS_PER_MSEC; } @@ -121553,6 +122667,7 @@ int64_t DatePart::MillisecondsOperator::Operation(dtime_tz_t input) { template <> int64_t DatePart::SecondsOperator::Operation(timestamp_t input) { + D_ASSERT(Timestamp::IsFinite(input)); return MicrosecondsOperator::Operation(input) / Interval::MICROS_PER_SEC; } @@ -121573,6 +122688,7 @@ int64_t DatePart::SecondsOperator::Operation(dtime_tz_t input) { template <> int64_t DatePart::MinutesOperator::Operation(timestamp_t input) { + D_ASSERT(Timestamp::IsFinite(input)); auto time = Timestamp::GetTime(input); // remove the hour part, and truncate to minutes return (time.micros % Interval::MICROS_PER_HOUR) / Interval::MICROS_PER_MINUTE; @@ -121597,6 +122713,7 @@ int64_t DatePart::MinutesOperator::Operation(dtime_tz_t input) { template <> int64_t DatePart::HoursOperator::Operation(timestamp_t input) { + D_ASSERT(Timestamp::IsFinite(input)); return Timestamp::GetTime(input).micros / Interval::MICROS_PER_HOUR; } @@ -121617,6 +122734,7 @@ int64_t DatePart::HoursOperator::Operation(dtime_tz_t input) { template <> double DatePart::EpochOperator::Operation(timestamp_t input) { + D_ASSERT(Timestamp::IsFinite(input)); return Timestamp::GetEpochMicroSeconds(input) / double(Interval::MICROS_PER_SEC); } @@ -121663,6 +122781,7 @@ unique_ptr DatePart::EpochOperator::PropagateStatistics template <> int64_t DatePart::EraOperator::Operation(timestamp_t input) { + D_ASSERT(Timestamp::IsFinite(input)); return EraOperator::Operation(Timestamp::GetDate(input)); } @@ -121852,6 +122971,7 @@ void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec & template <> void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &double_values, const timestamp_t &input, const idx_t idx, const part_mask_t mask) { + D_ASSERT(Timestamp::IsFinite(input)); date_t d; dtime_t t; Timestamp::Convert(input, d, t); @@ -123818,6 +124938,7 @@ ScalarFunction ToTimestampFun::GetFunction() { + //===----------------------------------------------------------------------===// // DuckDB // @@ -123930,7 +125051,8 @@ namespace duckdb { struct MakeDateOperator { template static RESULT_TYPE Operation(YYYY yyyy, MM mm, DD dd) { - return Date::FromDate(yyyy, mm, dd); + return Date::FromDate(Cast::Operation(yyyy), Cast::Operation(mm), + Cast::Operation(dd)); } }; @@ -123945,6 +125067,16 @@ static void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &re MakeDateOperator::Operation); } +template +static date_t FromDateCast(T year, T month, T day) { + date_t result; + if (!Date::TryFromDate(Cast::Operation(year), Cast::Operation(month), + Cast::Operation(day), result)) { + throw ConversionException("Date out of range: %d-%d-%d", year, month, day); + } + return result; +} + template static void ExecuteStructMakeDate(DataChunk &input, ExpressionState &state, Vector &result) { // this should be guaranteed by the binder @@ -123957,18 +125089,28 @@ static void ExecuteStructMakeDate(DataChunk &input, ExpressionState &state, Vect auto &mm = *children[1]; auto &dd = *children[2]; - TernaryExecutor::Execute(yyyy, mm, dd, result, input.size(), Date::FromDate); + TernaryExecutor::Execute(yyyy, mm, dd, result, input.size(), FromDateCast); } struct MakeTimeOperator { template static RESULT_TYPE Operation(HH hh, MM mm, SS ss) { - int64_t secs = ss; - int64_t micros = std::round((ss - secs) * Interval::MICROS_PER_SEC); - if (!Time::IsValidTime(hh, mm, secs, micros)) { - throw ConversionException("Time out of range: %d:%d:%d.%d", hh, mm, secs, micros); + + auto hh_32 = Cast::Operation(hh); + auto mm_32 = Cast::Operation(mm); + // Have to check this separately because safe casting of DOUBLE => INT32 can round. + int32_t ss_32 = 0; + if (ss < 0 || ss > Interval::SECS_PER_MINUTE) { + ss_32 = Cast::Operation(ss); + } else { + ss_32 = UnsafeNumericCast(ss); + } + auto micros = UnsafeNumericCast(std::round((ss - ss_32) * Interval::MICROS_PER_SEC)); + + if (!Time::IsValidTime(hh_32, mm_32, ss_32, micros)) { + throw ConversionException("Time out of range: %d:%d:%d.%d", hh_32, mm_32, ss_32, micros); } - return Time::FromTime(hh, mm, secs, micros); + return Time::FromTime(hh_32, mm_32, ss_32, micros); } }; @@ -124790,7 +125932,9 @@ struct ToWeeksOperator { static inline TR Operation(TA input) { interval_t result; result.months = 0; - result.days = input * 7; + if (!TryMultiplyOperator::Operation(input, Interval::DAYS_PER_WEEK, result.days)) { + throw OutOfRangeException("Interval value %d weeks out of range", input); + } result.micros = 0; return result; } @@ -125619,7 +126763,7 @@ unique_ptr ListSliceBindData::Copy() const { } template -static int CalculateSliceLength(idx_t begin, idx_t end, INDEX_TYPE step, bool svalid) { +static idx_t CalculateSliceLength(idx_t begin, idx_t end, INDEX_TYPE step, bool svalid) { if (step < 0) { step = abs(step); } @@ -125627,7 +126771,7 @@ static int CalculateSliceLength(idx_t begin, idx_t end, INDEX_TYPE step, bool sv throw InvalidInputException("Slice step cannot be zero"); } if (step == 1) { - return end - begin; + return NumericCast(end - begin); } else if (static_cast(step) >= (end - begin)) { return 1; } @@ -125770,7 +126914,7 @@ static void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &beg clamp_result = ClampSlice(str, begin, end); } - auto sel_length = 0; + idx_t sel_length = 0; bool sel_valid = false; if (step_vector && step_valid && str_valid && begin_valid && end_valid && step != 1 && end - begin > 0) { sel_length = CalculateSliceLength(begin, end, step, step_valid); @@ -125789,6 +126933,7 @@ static void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &beg if (sel_valid) { result_child_vector->Slice(sel, sel_length); + result_child_vector->Flatten(sel_length); ListVector::SetListSize(result, sel_length); } } @@ -125844,7 +126989,7 @@ static void ExecuteFlatSlice(Vector &result, Vector &list_vector, Vector &begin_ clamp_result = ClampSlice(sliced, begin, end); } - auto length = 0; + idx_t length = 0; if (end - begin > 0) { length = CalculateSliceLength(begin, end, step, step_valid); } @@ -125865,6 +127010,7 @@ static void ExecuteFlatSlice(Vector &result, Vector &list_vector, Vector &begin_ new_sel.set_index(i, sel.get_index(i)); } result_child_vector->Slice(new_sel, sel_length); + result_child_vector->Flatten(sel_length); ListVector::SetListSize(result, sel_length); } } @@ -125897,10 +127043,13 @@ static void ArraySliceFunction(DataChunk &args, ExpressionState &state, Vector & D_ASSERT(args.data.size() == 3 || args.data.size() == 4); auto count = args.size(); - Vector &list_or_str_vector = args.data[0]; + Vector &list_or_str_vector = result; + // this ensures that we do not change the input chunk + VectorOperations::Copy(args.data[0], list_or_str_vector, count, 0, 0); + if (list_or_str_vector.GetType().id() == LogicalTypeId::SQLNULL) { - auto &result_validity = FlatVector::Validity(result); - result_validity.SetInvalid(0); + result.SetVectorType(VectorType::CONSTANT_VECTOR); + ConstantVector::SetNull(result, true); return; } @@ -125925,7 +127074,6 @@ static void ArraySliceFunction(DataChunk &args, ExpressionState &state, Vector & list_or_str_vector.GetVectorType() != VectorType::CONSTANT_VECTOR) { list_or_str_vector.Flatten(count); } - ListVector::ReferenceEntry(result, list_or_str_vector); ExecuteSlice(result, list_or_str_vector, begin_vector, end_vector, step_vector, count, begin_is_empty, end_is_empty); break; @@ -126374,7 +127522,8 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect auto &result_validity = FlatVector::Validity(result); if (lists.GetType().id() == LogicalTypeId::SQLNULL) { - result_validity.SetInvalid(0); + result.SetVectorType(VectorType::CONSTANT_VECTOR); + ConstantVector::SetNull(result, true); return; } @@ -127019,7 +128168,6 @@ struct ReduceExecuteInfo { active_rows.Resize(0, info.row_count); active_rows.SetAllValid(info.row_count); - right_sel.Initialize(info.row_count); left_sel.Initialize(info.row_count); active_rows_sel.Initialize(info.row_count); @@ -127058,7 +128206,6 @@ struct ReduceExecuteInfo { unique_ptr expr_executor; vector input_types; - SelectionVector right_sel; SelectionVector left_sel; SelectionVector active_rows_sel; }; @@ -127072,6 +128219,10 @@ static bool ExecuteReduce(idx_t loops, ReduceExecuteInfo &execute_info, LambdaFu // create selection vectors for the left and right slice auto data = execute_info.active_rows.GetData(); + // reset right_sel each iteration to prevent referencing issues + SelectionVector right_sel; + right_sel.Initialize(info.row_count); + idx_t bits_per_entry = sizeof(idx_t) * 8; for (idx_t entry_idx = 0; original_row_idx < info.row_count; entry_idx++) { if (data[entry_idx] == 0) { @@ -127086,8 +128237,7 @@ static bool ExecuteReduce(idx_t loops, ReduceExecuteInfo &execute_info, LambdaFu } auto list_column_format_index = info.list_column_format.sel->get_index(original_row_idx); if (info.list_entries[list_column_format_index].length > loops + 1) { - execute_info.right_sel.set_index(reduced_row_idx, - info.list_entries[list_column_format_index].offset + loops + 1); + right_sel.set_index(reduced_row_idx, info.list_entries[list_column_format_index].offset + loops + 1); execute_info.left_sel.set_index(reduced_row_idx, valid_row_idx); execute_info.active_rows_sel.set_index(reduced_row_idx, original_row_idx); @@ -127110,7 +128260,7 @@ static bool ExecuteReduce(idx_t loops, ReduceExecuteInfo &execute_info, LambdaFu // slice the left and right slice execute_info.left_slice.Slice(execute_info.left_slice, execute_info.left_sel, reduced_row_idx); - Vector right_slice(*info.child_vector, execute_info.right_sel, reduced_row_idx); + Vector right_slice(*info.child_vector, right_sel, reduced_row_idx); // create the input chunk DataChunk input_chunk; @@ -127421,8 +128571,8 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re auto source_idx = list_entry.offset + child_idx; sel.set_index(offset_lists_indices, source_idx); - lists_indices_data[offset_lists_indices] = (uint32_t)i; - payload_vector_data[offset_lists_indices] = source_idx; + lists_indices_data[offset_lists_indices] = UnsafeNumericCast(i); + payload_vector_data[offset_lists_indices] = NumericCast(source_idx); offset_lists_indices++; incr_payload_count++; } @@ -127543,6 +128693,8 @@ static unique_ptr ListGradeUpBind(ClientContext &context, ScalarFu order = config.ResolveOrder(order); null_order = config.ResolveNullOrder(order, null_order); + arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0])); + bound_function.arguments[0] = arguments[0]->return_type; bound_function.return_type = LogicalType::LIST(LogicalTypeId::BIGINT); auto child_type = ListType::GetChildType(arguments[0]->return_type); @@ -127726,6 +128878,7 @@ static void ListValueFunction(DataChunk &args, ExpressionState &state, Vector &r result.Verify(args.size()); } +template static unique_ptr ListValueBind(ClientContext &context, ScalarFunction &bound_function, vector> &arguments) { // collect names and deconflict, construct return type @@ -127734,20 +128887,28 @@ static unique_ptr ListValueBind(ClientContext &context, ScalarFunc for (idx_t i = 1; i < arguments.size(); i++) { auto arg_type = ExpressionBinder::GetExpressionReturnType(*arguments[i]); if (!LogicalType::TryGetMaxLogicalType(context, child_type, arg_type, child_type)) { - string list_arguments = "Full list: "; - idx_t error_index = list_arguments.size(); - for (idx_t k = 0; k < arguments.size(); k++) { - if (k > 0) { - list_arguments += ", "; - } - if (k == i) { - error_index = list_arguments.size(); + if (IS_UNPIVOT) { + string list_arguments = "Full list: "; + idx_t error_index = list_arguments.size(); + for (idx_t k = 0; k < arguments.size(); k++) { + if (k > 0) { + list_arguments += ", "; + } + if (k == i) { + error_index = list_arguments.size(); + } + list_arguments += arguments[k]->ToString() + " " + arguments[k]->return_type.ToString(); } - list_arguments += arguments[k]->ToString() + " " + arguments[k]->return_type.ToString(); + auto error = + StringUtil::Format("Cannot unpivot columns of types %s and %s - an explicit cast is required", + child_type.ToString(), arg_type.ToString()); + throw BinderException(arguments[i]->query_location, + QueryErrorContext::Format(list_arguments, error, int(error_index), false)); + } else { + throw BinderException(arguments[i]->query_location, + "Cannot create a list of types %s and %s - an explicit cast is required", + child_type.ToString(), arg_type.ToString()); } - auto error = StringUtil::Format("Cannot create a list of types %s and %s - an explicit cast is required", - child_type.ToString(), arg_type.ToString()); - throw BinderException(QueryErrorContext::Format(list_arguments, error, int(error_index), false)); } } child_type = LogicalType::NormalizeType(child_type); @@ -127778,6 +128939,13 @@ ScalarFunction ListValueFun::GetFunction() { return fun; } +ScalarFunction UnpivotListFun::GetFunction() { + auto fun = ListValueFun::GetFunction(); + fun.name = "unpivot_list"; + fun.bind = ListValueBind; + return fun; +} + } // namespace duckdb @@ -128115,211 +129283,180 @@ ScalarFunction CardinalityFun::GetFunction() { namespace duckdb { -// Example: -// source: [1,2,3], expansion_factor: 4 -// target (result): [1,2,3,1,2,3,1,2,3,1,2,3] -static void CreateExpandedVector(const Vector &source, Vector &target, idx_t expansion_factor) { - idx_t count = ListVector::GetListSize(source); - auto &entry = ListVector::GetEntry(source); +static void MapFunctionEmptyInput(Vector &result, const idx_t row_count) { - idx_t target_idx = 0; - for (idx_t copy = 0; copy < expansion_factor; copy++) { - for (idx_t key_idx = 0; key_idx < count; key_idx++) { - target.SetValue(target_idx, entry.GetValue(key_idx)); - target_idx++; - } - } - D_ASSERT(target_idx == count * expansion_factor); -} + // if no chunk is set in ExpressionExecutor::ExecuteExpression (args.data.empty(), e.g., + // in SELECT MAP()), then we always pass a row_count of 1 + result.SetVectorType(VectorType::CONSTANT_VECTOR); + ListVector::SetListSize(result, 0); -static void AlignVectorToReference(const Vector &original, const Vector &reference, idx_t tuple_count, Vector &result) { - auto original_length = ListVector::GetListSize(original); - auto new_length = ListVector::GetListSize(reference); + auto result_data = ListVector::GetData(result); + result_data[0] = list_entry_t(); + result.Verify(row_count); +} - Vector expanded_const(ListType::GetChildType(original.GetType()), new_length); +static void MapFunction(DataChunk &args, ExpressionState &, Vector &result) { - if (new_length != tuple_count * original_length) { - throw InvalidInputException("Error in MAP creation: key list and value list do not align. i.e. different " - "size or incompatible structure"); - } - auto expansion_factor = original_length ? new_length / original_length : original_length; - CreateExpandedVector(original, expanded_const, expansion_factor); + // internal MAP representation + // - LIST-vector that contains STRUCTs as child entries + // - STRUCTs have exactly two fields, a key-field, and a value-field + // - key names are unique - result.Reference(expanded_const); -} + D_ASSERT(result.GetType().id() == LogicalTypeId::MAP); + auto row_count = args.size(); -static bool ListEntriesEqual(Vector &keys, Vector &values, idx_t count) { - auto key_count = ListVector::GetListSize(keys); - auto value_count = ListVector::GetListSize(values); - bool same_vector_type = keys.GetVectorType() == values.GetVectorType(); + // early-out, if no data + if (args.data.empty()) { + return MapFunctionEmptyInput(result, row_count); + } - D_ASSERT(keys.GetType().id() == LogicalTypeId::LIST); - D_ASSERT(values.GetType().id() == LogicalTypeId::LIST); + auto &keys = args.data[0]; + auto &values = args.data[1]; + // a LIST vector, where each row contains a LIST of KEYS UnifiedVectorFormat keys_data; - UnifiedVectorFormat values_data; + keys.ToUnifiedFormat(row_count, keys_data); + auto keys_entries = UnifiedVectorFormat::GetData(keys_data); - keys.ToUnifiedFormat(count, keys_data); - values.ToUnifiedFormat(count, values_data); + // the KEYs child vector + auto keys_child_vector = ListVector::GetEntry(keys); + UnifiedVectorFormat keys_child_data; + keys_child_vector.ToUnifiedFormat(ListVector::GetListSize(keys), keys_child_data); - auto keys_entries = UnifiedVectorFormat::GetData(keys_data); + // a LIST vector, where each row contains a LIST of VALUES + UnifiedVectorFormat values_data; + values.ToUnifiedFormat(row_count, values_data); auto values_entries = UnifiedVectorFormat::GetData(values_data); - if (same_vector_type) { - const auto key_data = keys_data.data; - const auto value_data = values_data.data; + // the VALUEs child vector + auto values_child_vector = ListVector::GetEntry(values); + UnifiedVectorFormat values_child_data; + values_child_vector.ToUnifiedFormat(ListVector::GetListSize(values), values_child_data); - if (keys.GetVectorType() == VectorType::CONSTANT_VECTOR) { - D_ASSERT(values.GetVectorType() == VectorType::CONSTANT_VECTOR); - // Only need to compare one entry in this case - return memcmp(key_data, value_data, sizeof(list_entry_t)) == 0; - } - - // Fast path if the vector types are equal, can just check if the entries are the same - if (key_count != value_count) { - return false; + // a LIST vector, where each row contains a MAP (LIST of STRUCTs) + UnifiedVectorFormat result_data; + result.ToUnifiedFormat(row_count, result_data); + auto result_entries = UnifiedVectorFormat::GetDataNoConst(result_data); + result_data.validity.SetAllValid(row_count); + + // get the resulting size of the key/value child lists + idx_t result_child_size = 0; + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + auto keys_idx = keys_data.sel->get_index(row_idx); + if (!keys_data.validity.RowIsValid(keys_idx)) { + continue; } - return memcmp(key_data, value_data, count * sizeof(list_entry_t)) == 0; + auto keys_entry = keys_entries[keys_idx]; + result_child_size += keys_entry.length; } - // Compare the list_entries one by one - for (idx_t i = 0; i < count; i++) { - auto keys_idx = keys_data.sel->get_index(i); - auto values_idx = values_data.sel->get_index(i); + // we need to slice potential non-flat vectors + SelectionVector sel_keys(result_child_size); + SelectionVector sel_values(result_child_size); + idx_t offset = 0; - if (keys_entries[keys_idx] != values_entries[values_idx]) { - return false; - } - } - return true; -} + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { -static list_entry_t *GetBiggestList(Vector &key, Vector &value, idx_t &size) { - auto key_size = ListVector::GetListSize(key); - auto value_size = ListVector::GetListSize(value); - if (key_size > value_size) { - size = key_size; - return ListVector::GetData(key); - } - size = value_size; - return ListVector::GetData(value); -} + auto keys_idx = keys_data.sel->get_index(row_idx); + auto values_idx = values_data.sel->get_index(row_idx); + auto result_idx = result_data.sel->get_index(row_idx); -static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result) { - D_ASSERT(result.GetType().id() == LogicalTypeId::MAP); - - auto count = args.size(); + // empty map + if (!keys_data.validity.RowIsValid(keys_idx) && !values_data.validity.RowIsValid(values_idx)) { + result_entries[result_idx] = list_entry_t(); + continue; + } - auto &map_key_vector = MapVector::GetKeys(result); - auto &map_value_vector = MapVector::GetValues(result); - auto result_data = ListVector::GetData(result); + auto keys_entry = keys_entries[keys_idx]; + auto values_entry = values_entries[values_idx]; - result.SetVectorType(VectorType::CONSTANT_VECTOR); - if (args.data.empty()) { - ListVector::SetListSize(result, 0); - result_data->offset = 0; - result_data->length = 0; - result.Verify(count); - return; - } + // validity checks + if (!keys_data.validity.RowIsValid(keys_idx)) { + MapVector::EvalMapInvalidReason(MapInvalidReason::NULL_KEY_LIST); + } + if (!values_data.validity.RowIsValid(values_idx)) { + MapVector::EvalMapInvalidReason(MapInvalidReason::NULL_VALUE_LIST); + } + if (keys_entry.length != values_entry.length) { + MapVector::EvalMapInvalidReason(MapInvalidReason::NOT_ALIGNED); + } - D_ASSERT(args.ColumnCount() == 2); - auto &key_vector = args.data[0]; - auto &value_vector = args.data[1]; + // set the selection vectors and perform a duplicate key check + value_set_t unique_keys; + for (idx_t child_idx = 0; child_idx < keys_entry.length; child_idx++) { - if (args.AllConstant()) { - auto key_data = ListVector::GetData(key_vector); - auto value_data = ListVector::GetData(value_vector); - auto key_entry = key_data[0]; - auto value_entry = value_data[0]; - if (key_entry != value_entry) { - throw BinderException("Key and value list sizes don't match"); - } - result_data[0] = key_entry; - ListVector::SetListSize(result, ListVector::GetListSize(key_vector)); - map_key_vector.Reference(ListVector::GetEntry(key_vector)); - map_value_vector.Reference(ListVector::GetEntry(value_vector)); - MapVector::MapConversionVerify(result, count); - result.Verify(count); - return; - } + auto key_idx = keys_child_data.sel->get_index(keys_entry.offset + child_idx); + auto value_idx = values_child_data.sel->get_index(values_entry.offset + child_idx); - result.SetVectorType(VectorType::FLAT_VECTOR); + // NULL check + if (!keys_child_data.validity.RowIsValid(key_idx)) { + MapVector::EvalMapInvalidReason(MapInvalidReason::NULL_KEY); + } - if (key_vector.GetVectorType() == VectorType::CONSTANT_VECTOR) { - D_ASSERT(value_vector.GetVectorType() != VectorType::CONSTANT_VECTOR); - Vector expanded_const(ListType::GetChildType(key_vector.GetType()), count); - AlignVectorToReference(key_vector, value_vector, count, expanded_const); - map_key_vector.Reference(expanded_const); - - value_vector.Flatten(count); - map_value_vector.Reference(ListVector::GetEntry(value_vector)); - } else if (value_vector.GetVectorType() == VectorType::CONSTANT_VECTOR) { - D_ASSERT(key_vector.GetVectorType() != VectorType::CONSTANT_VECTOR); - Vector expanded_const(ListType::GetChildType(value_vector.GetType()), count); - AlignVectorToReference(value_vector, key_vector, count, expanded_const); - map_value_vector.Reference(expanded_const); - - key_vector.Flatten(count); - map_key_vector.Reference(ListVector::GetEntry(key_vector)); - } else { - key_vector.Flatten(count); - value_vector.Flatten(count); + // unique check + auto value = keys_child_vector.GetValue(key_idx); + auto unique = unique_keys.insert(value).second; + if (!unique) { + MapVector::EvalMapInvalidReason(MapInvalidReason::DUPLICATE_KEY); + } - if (!ListEntriesEqual(key_vector, value_vector, count)) { - throw InvalidInputException("Error in MAP creation: key list and value list do not align. i.e. different " - "size or incompatible structure"); + // set selection vectors + sel_keys.set_index(offset + child_idx, key_idx); + sel_values.set_index(offset + child_idx, value_idx); } - map_value_vector.Reference(ListVector::GetEntry(value_vector)); - map_key_vector.Reference(ListVector::GetEntry(key_vector)); + // keys_entry and values_entry have the same length + result_entries[result_idx].length = keys_entry.length; + result_entries[result_idx].offset = offset; + offset += keys_entry.length; } + D_ASSERT(offset == result_child_size); - idx_t list_size; - auto src_data = GetBiggestList(key_vector, value_vector, list_size); - ListVector::SetListSize(result, list_size); + auto &result_key_vector = MapVector::GetKeys(result); + auto &result_value_vector = MapVector::GetValues(result); - result_data = ListVector::GetData(result); - for (idx_t i = 0; i < count; i++) { - result_data[i] = src_data[i]; - } + ListVector::SetListSize(result, offset); + result_key_vector.Slice(keys_child_vector, sel_keys, offset); + result_key_vector.Flatten(offset); + result_value_vector.Slice(values_child_vector, sel_values, offset); + result_value_vector.Flatten(offset); - MapVector::MapConversionVerify(result, count); - result.Verify(count); + if (args.AllConstant()) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } + result.Verify(row_count); } -static unique_ptr MapBind(ClientContext &context, ScalarFunction &bound_function, +static unique_ptr MapBind(ClientContext &, ScalarFunction &bound_function, vector> &arguments) { - child_list_t child_types; if (arguments.size() != 2 && !arguments.empty()) { - throw InvalidInputException("We need exactly two lists for a map"); - } - if (arguments.size() == 2) { - if (arguments[0]->return_type.id() != LogicalTypeId::LIST) { - throw InvalidInputException("First argument is not a list"); - } - if (arguments[1]->return_type.id() != LogicalTypeId::LIST) { - throw InvalidInputException("Second argument is not a list"); - } - child_types.push_back(make_pair("key", arguments[0]->return_type)); - child_types.push_back(make_pair("value", arguments[1]->return_type)); + MapVector::EvalMapInvalidReason(MapInvalidReason::INVALID_PARAMS); } + // bind an empty MAP if (arguments.empty()) { - auto empty = LogicalType::LIST(LogicalTypeId::SQLNULL); - child_types.push_back(make_pair("key", empty)); - child_types.push_back(make_pair("value", empty)); + bound_function.return_type = LogicalType::MAP(LogicalTypeId::SQLNULL, LogicalTypeId::SQLNULL); + return make_uniq(bound_function.return_type); + } + + // bind a MAP with key-value pairs + D_ASSERT(arguments.size() == 2); + if (arguments[0]->return_type.id() != LogicalTypeId::LIST) { + MapVector::EvalMapInvalidReason(MapInvalidReason::INVALID_PARAMS); + } + if (arguments[1]->return_type.id() != LogicalTypeId::LIST) { + MapVector::EvalMapInvalidReason(MapInvalidReason::INVALID_PARAMS); } - bound_function.return_type = - LogicalType::MAP(ListType::GetChildType(child_types[0].second), ListType::GetChildType(child_types[1].second)); + auto key_type = ListType::GetChildType(arguments[0]->return_type); + auto value_type = ListType::GetChildType(arguments[1]->return_type); + bound_function.return_type = LogicalType::MAP(key_type, value_type); return make_uniq(bound_function.return_type); } ScalarFunction MapFun::GetFunction() { - //! the arguments and return types are actually set in the binder function ScalarFunction fun({}, LogicalTypeId::MAP, MapFunction, MapBind); fun.varargs = LogicalType::ANY; fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; @@ -129227,14 +130364,14 @@ unique_ptr BindGenericRoundFunctionDecimal(ClientContext &context, struct CeilDecimalOperator { template static void Operation(DataChunk &input, uint8_t scale, Vector &result) { - T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]; + T power_of_ten = UnsafeNumericCast(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]); UnaryExecutor::Execute(input.data[0], result, input.size(), [&](T input) { if (input <= 0) { // below 0 we floor the number (e.g. -10.5 -> -10) - return input / power_of_ten; + return UnsafeNumericCast(input / power_of_ten); } else { // above 0 we ceil the number - return ((input - 1) / power_of_ten) + 1; + return UnsafeNumericCast(((input - 1) / power_of_ten) + 1); } }); } @@ -129280,14 +130417,14 @@ struct FloorOperator { struct FloorDecimalOperator { template static void Operation(DataChunk &input, uint8_t scale, Vector &result) { - T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]; + T power_of_ten = UnsafeNumericCast(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]); UnaryExecutor::Execute(input.data[0], result, input.size(), [&](T input) { if (input < 0) { // below 0 we ceil the number (e.g. -10.5 -> -11) - return ((input + 1) / power_of_ten) - 1; + return UnsafeNumericCast(((input + 1) / power_of_ten) - 1); } else { // above 0 we floor the number - return input / power_of_ten; + return UnsafeNumericCast(input / power_of_ten); } }); } @@ -129334,10 +130471,10 @@ struct TruncOperator { struct TruncDecimalOperator { template static void Operation(DataChunk &input, uint8_t scale, Vector &result) { - T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]; + T power_of_ten = UnsafeNumericCast(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]); UnaryExecutor::Execute(input.data[0], result, input.size(), [&](T input) { // Always floor - return (input / power_of_ten); + return UnsafeNumericCast((input / power_of_ten)); }); } }; @@ -129416,7 +130553,7 @@ struct RoundOperator { struct RoundDecimalOperator { template static void Operation(DataChunk &input, uint8_t scale, Vector &result) { - T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]; + T power_of_ten = UnsafeNumericCast(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]); T addition = power_of_ten / 2; // regular round rounds towards the nearest number // in case of a tie we round away from zero @@ -129431,7 +130568,7 @@ struct RoundDecimalOperator { } else { input += addition; } - return input / power_of_ten; + return UnsafeNumericCast(input / power_of_ten); }); } }; @@ -129464,8 +130601,8 @@ static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionSt result.SetValue(0, Value::INTEGER(0)); return; } - T divide_power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale + source_scale]; - T multiply_power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale]; + T divide_power_of_ten = UnsafeNumericCast(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale + source_scale]); + T multiply_power_of_ten = UnsafeNumericCast(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale]); T addition = divide_power_of_ten / 2; UnaryExecutor::Execute(input.data[0], result, input.size(), [&](T input) { @@ -129474,7 +130611,7 @@ static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionSt } else { input += addition; } - return input / divide_power_of_ten * multiply_power_of_ten; + return UnsafeNumericCast(input / divide_power_of_ten * multiply_power_of_ten); }); } @@ -129483,7 +130620,7 @@ static void DecimalRoundPositivePrecisionFunction(DataChunk &input, ExpressionSt auto &func_expr = state.expr.Cast(); auto &info = func_expr.bind_info->Cast(); auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type); - T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale]; + T power_of_ten = UnsafeNumericCast(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale]); T addition = power_of_ten / 2; UnaryExecutor::Execute(input.data[0], result, input.size(), [&](T input) { if (input < 0) { @@ -129491,7 +130628,7 @@ static void DecimalRoundPositivePrecisionFunction(DataChunk &input, ExpressionSt } else { input += addition; } - return input / power_of_ten; + return UnsafeNumericCast(input / power_of_ten); }); } @@ -129539,7 +130676,7 @@ unique_ptr BindDecimalRoundPrecision(ClientContext &context, Scala bound_function.function = ScalarFunction::NopFunction; target_scale = scale; } else { - target_scale = round_value; + target_scale = NumericCast(round_value); switch (decimal_type.InternalType()) { case PhysicalType::INT16: bound_function.function = DecimalRoundPositivePrecisionFunction; @@ -129998,6 +131135,9 @@ ScalarFunction Atan2Fun::GetFunction() { struct ACos { template static inline TR Operation(TA input) { + if (input < -1 || input > 1) { + throw InvalidInputException("ACOS is undefined outside [-1,1]"); + } return (double)std::acos(input); } }; @@ -130432,19 +131572,19 @@ struct BitwiseShiftLeftOperator { if (shift == 0) { return input; } - TA max_value = (TA(1) << (max_shift - shift - 1)); + TA max_value = UnsafeNumericCast((TA(1) << (max_shift - shift - 1))); if (input >= max_value) { throw OutOfRangeException("Overflow in left shift (%s << %s)", NumericHelper::ToString(input), NumericHelper::ToString(shift)); } - return input << shift; + return UnsafeNumericCast(input << shift); } }; static void BitwiseShiftLeftOperation(DataChunk &args, ExpressionState &state, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t shift) { - int32_t max_shift = Bit::BitLength(input); + auto max_shift = UnsafeNumericCast(Bit::BitLength(input)); if (shift == 0) { return input; } @@ -130491,7 +131631,7 @@ struct BitwiseShiftRightOperator { static void BitwiseShiftRightOperation(DataChunk &args, ExpressionState &state, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t shift) { - int32_t max_shift = Bit::BitLength(input); + auto max_shift = UnsafeNumericCast(Bit::BitLength(input)); if (shift == 0) { return input; } @@ -130979,6 +132119,10 @@ class SecretManager { //! Autoload extension for specific secret function void AutoloadExtensionForFunction(const string &type, const string &provider); + //! Will throw appropriate error message when type not found + [[noreturn]] void ThrowTypeNotFoundError(const string &type); + [[noreturn]] void ThrowProviderNotFoundError(const string &type, const string &provider, bool was_default = false); + //! Thread-safe accessors for secret_storages vector> GetSecretStorages(); optional_ptr GetSecretStorage(const string &name); @@ -131331,7 +132475,7 @@ struct GenericExecutor { for (idx_t i = 0; i < (constant ? 1 : count); i++) { auto a_idx = a_state.main_data.sel->get_index(i); - auto b_idx = a_state.main_data.sel->get_index(i); + auto b_idx = b_state.main_data.sel->get_index(i); if (!a_state.main_data.validity.RowIsValid(a_idx) || !b_state.main_data.validity.RowIsValid(b_idx)) { FlatVector::SetNull(result, i, true); continue; @@ -131365,8 +132509,8 @@ struct GenericExecutor { for (idx_t i = 0; i < (constant ? 1 : count); i++) { auto a_idx = a_state.main_data.sel->get_index(i); - auto b_idx = a_state.main_data.sel->get_index(i); - auto c_idx = a_state.main_data.sel->get_index(i); + auto b_idx = b_state.main_data.sel->get_index(i); + auto c_idx = c_state.main_data.sel->get_index(i); if (!a_state.main_data.validity.RowIsValid(a_idx) || !b_state.main_data.validity.RowIsValid(b_idx) || !c_state.main_data.validity.RowIsValid(c_idx)) { FlatVector::SetNull(result, i, true); @@ -131406,9 +132550,9 @@ struct GenericExecutor { for (idx_t i = 0; i < (constant ? 1 : count); i++) { auto a_idx = a_state.main_data.sel->get_index(i); - auto b_idx = a_state.main_data.sel->get_index(i); - auto c_idx = a_state.main_data.sel->get_index(i); - auto d_idx = a_state.main_data.sel->get_index(i); + auto b_idx = b_state.main_data.sel->get_index(i); + auto c_idx = c_state.main_data.sel->get_index(i); + auto d_idx = d_state.main_data.sel->get_index(i); if (!a_state.main_data.validity.RowIsValid(a_idx) || !b_state.main_data.validity.RowIsValid(b_idx) || !c_state.main_data.validity.RowIsValid(c_idx) || !d_state.main_data.validity.RowIsValid(d_idx)) { FlatVector::SetNull(result, i, true); @@ -131954,6 +133098,7 @@ struct CountZeros { + namespace duckdb { static void WriteHexBytes(uint64_t x, char *&output, idx_t buffer_size) { @@ -132255,7 +133400,7 @@ struct FromHexOperator { for (; i < size; i += 2) { uint8_t major = StringUtil::GetHexValue(data[i]); uint8_t minor = StringUtil::GetHexValue(data[i + 1]); - *output = (major << 4) | minor; + *output = UnsafeNumericCast((major << 4) | minor); output++; } @@ -132745,7 +133890,7 @@ struct BlockPatternMatchVector { for (int64_t i = 0; i < len; ++i) { int64_t block = i / 64; int64_t pos = i % 64; - insert(block, first[i], pos); + insert(block, first[i], static_cast(pos)); } } @@ -134025,7 +135170,7 @@ static string_t LeftPadFunction(const string_t &str, const int32_t len, const st // Append as much of the original string as fits result.insert(result.end(), data_str, data_str + written.first); - return string_t(result.data(), result.size()); + return string_t(result.data(), UnsafeNumericCast(result.size())); } struct LeftPadOperator { @@ -134054,7 +135199,7 @@ static string_t RightPadFunction(const string_t &str, const int32_t len, const s throw InvalidInputException("Insufficient padding in RPAD."); }; - return string_t(result.data(), result.size()); + return string_t(result.data(), UnsafeNumericCast(result.size())); } struct RightPadOperator { @@ -134650,7 +135795,7 @@ static string_t RepeatScalarFunction(const string_t &str, const int64_t cnt, vec result.insert(result.end(), input_str, input_str + size_str); } - return string_t(result.data(), result.size()); + return string_t(result.data(), UnsafeNumericCast(result.size())); } static void RepeatFunction(DataChunk &args, ExpressionState &state, Vector &result) { @@ -134734,7 +135879,7 @@ static string_t ReplaceScalarFunction(const string_t &haystack, const string_t & size_haystack -= size_needle; } - return string_t(result.data(), result.size()); + return string_t(result.data(), UnsafeNumericCast(result.size())); } static void ReplaceFunction(DataChunk &args, ExpressionState &state, Vector &result) { @@ -135074,7 +136219,8 @@ struct StringSplitInput { ListVector::SetListSize(result_list, offset + list_idx); ListVector::Reserve(result_list, ListVector::GetListCapacity(result_list) * 2); } - FlatVector::GetData(result_child)[list_entry] = string_t(split_data, split_size); + FlatVector::GetData(result_child)[list_entry] = + string_t(split_data, UnsafeNumericCast(split_size)); } }; @@ -135384,7 +136530,7 @@ static string_t TranslateScalarFunction(const string_t &haystack, const string_t input_haystack += sz; } - return string_t(result.data(), result.size()); + return string_t(result.data(), UnsafeNumericCast(result.size())); } static void TranslateFunction(DataChunk &args, ExpressionState &state, Vector &result) { @@ -136122,7 +137268,7 @@ void AdaptiveFilter::AdaptRuntimeStatistics(double duration) { prev_mean = runtime_sum / iteration_count; // get swap index and swap likeliness - std::uniform_int_distribution distribution(1, right_random_border); // a <= i <= b + std::uniform_int_distribution distribution(1, NumericCast(right_random_border)); // a <= i <= b idx_t random_number = distribution(generator) - 1; swap_idx = random_number / 100; // index to be swapped @@ -136594,7 +137740,7 @@ void GroupedAggregateHashTable::Resize(idx_t size) { // Find an empty entry auto entry_idx = ApplyBitMask(hash); D_ASSERT(entry_idx == hash % capacity); - while (entries[entry_idx].IsOccupied() > 0) { + while (entries[entry_idx].IsOccupied()) { entry_idx++; if (entry_idx >= capacity) { entry_idx = 0; @@ -136986,13 +138132,14 @@ namespace duckdb { //! are used within the execution engine class ColumnBindingResolver : public LogicalOperatorVisitor { public: - ColumnBindingResolver(); + ColumnBindingResolver(bool verify_only = false); void VisitOperator(LogicalOperator &op) override; static void Verify(LogicalOperator &op); protected: vector bindings; + bool verify_only; unique_ptr VisitReplace(BoundColumnRefExpression &expr, unique_ptr *expr_ptr) override; static unordered_set VerifyInternal(LogicalOperator &op); @@ -137382,7 +138529,7 @@ class LogicalInsert : public LogicalOperator { // The types of the columns targeted by the DO UPDATE SET expressions vector set_types; // The table_index referring to the column references qualified with 'excluded' - idx_t excluded_table_index; + idx_t excluded_table_index = 0; // The columns to fetch from the 'destination' table vector columns_to_fetch; // The columns to fetch from the 'source' table @@ -137408,7 +138555,7 @@ class LogicalInsert : public LogicalOperator { namespace duckdb { -ColumnBindingResolver::ColumnBindingResolver() { +ColumnBindingResolver::ColumnBindingResolver(bool verify_only) : verify_only(verify_only) { } void ColumnBindingResolver::VisitOperator(LogicalOperator &op) { @@ -137548,6 +138695,10 @@ unique_ptr ColumnBindingResolver::VisitReplace(BoundColumnRefExpress // check the current set of column bindings to see which index corresponds to the column reference for (idx_t i = 0; i < bindings.size(); i++) { if (expr.binding == bindings[i]) { + if (verify_only) { + // in verification mode + return nullptr; + } return make_uniq(expr.alias, expr.return_type, i); } } @@ -137593,6 +138744,8 @@ unordered_set ColumnBindingResolver::VerifyInternal(LogicalOperator &op) void ColumnBindingResolver::Verify(LogicalOperator &op) { #ifdef DEBUG + ColumnBindingResolver resolver(true); + resolver.VisitOperator(op); VerifyInternal(op); #endif } @@ -137814,7 +138967,7 @@ void ExpressionExecutor::Execute(const BoundCaseExpression &expr, ExpressionStat } else { // we need to execute and then fill in the desired tuples in the result Execute(*case_check.then_expr, then_state, current_true_sel, tcount, intermediate_result); - FillSwitch(intermediate_result, result, *current_true_sel, tcount); + FillSwitch(intermediate_result, result, *current_true_sel, NumericCast(tcount)); } // continue with the false tuples current_sel = current_false_sel; @@ -137835,7 +138988,7 @@ void ExpressionExecutor::Execute(const BoundCaseExpression &expr, ExpressionStat D_ASSERT(current_sel); Execute(*expr.else_expr, else_state, current_sel, current_count, intermediate_result); - FillSwitch(intermediate_result, result, *current_sel, current_count); + FillSwitch(intermediate_result, result, *current_sel, NumericCast(current_count)); } } if (sel) { @@ -138012,11 +139165,13 @@ void ExpressionExecutor::Execute(const BoundCastExpression &expr, ExpressionStat if (expr.try_cast) { string error_message; CastParameters parameters(expr.bound_cast.cast_data.get(), false, &error_message, lstate); + parameters.query_location = expr.query_location; expr.bound_cast.function(child, result, count, parameters); } else { // cast it to the type specified by the cast expression D_ASSERT(result.GetType() == expr.return_type); CastParameters parameters(expr.bound_cast.cast_data.get(), false, nullptr, lstate); + parameters.query_location = expr.query_location; expr.bound_cast.function(child, result, count, parameters); } } @@ -138572,14 +139727,14 @@ void ExpressionExecutor::Execute(const BoundFunctionExpression &expr, Expression } #endif } - arguments.Verify(); } arguments.SetCardinality(count); + arguments.Verify(); state->profiler.BeginSample(); D_ASSERT(expr.function.function); expr.function.function(arguments, *state, result); - state->profiler.EndSample(count); + state->profiler.EndSample(NumericCast(count)); VerifyNullHandling(expr, arguments, result); D_ASSERT(result.GetType() == expr.return_type); @@ -138678,7 +139833,7 @@ void ExpressionExecutor::Execute(const BoundOperatorExpression &expr, Expression } if (result_count > 0) { vector_to_check.Slice(slice_sel, result_count); - FillSwitch(vector_to_check, result, result_sel, result_count); + FillSwitch(vector_to_check, result, result_sel, NumericCast(result_count)); } current_sel = next_sel; next_sel = next_sel == &sel_a ? &sel_b : &sel_a; @@ -138862,7 +140017,7 @@ idx_t ExpressionExecutor::SelectExpression(DataChunk &input, SelectionVector &se SetChunk(&input); states[0]->profiler.BeginSample(); idx_t selected_tuples = Select(*expressions[0], states[0]->root_state.get(), nullptr, input.size(), &sel, nullptr); - states[0]->profiler.EndSample(chunk ? chunk->size() : 0); + states[0]->profiler.EndSample(NumericCast(chunk ? chunk->size() : 0)); return selected_tuples; } @@ -138876,7 +140031,7 @@ void ExpressionExecutor::ExecuteExpression(idx_t expr_idx, Vector &result) { D_ASSERT(result.GetType().id() == expressions[expr_idx]->return_type.id()); states[expr_idx]->profiler.BeginSample(); Execute(*expressions[expr_idx], states[expr_idx]->root_state.get(), nullptr, chunk ? chunk->size() : 1, result); - states[expr_idx]->profiler.EndSample(chunk ? chunk->size() : 0); + states[expr_idx]->profiler.EndSample(NumericCast(chunk ? chunk->size() : 0)); } Value ExpressionExecutor::EvaluateScalar(ClientContext &context, const Expression &expr, bool allow_unfoldable) { @@ -138911,6 +140066,9 @@ void ExpressionExecutor::Verify(const Expression &expr, Vector &vector, idx_t co if (expr.verification_stats) { expr.verification_stats->Verify(vector, count); } +#ifdef DUCKDB_VERIFY_DICTIONARY_EXPRESSION + Vector::DebugTransformToDictionary(vector, count); +#endif } unique_ptr ExpressionExecutor::InitializeState(const Expression &expr, @@ -140640,7 +141798,8 @@ bool Construct(ART &art, vector &keys, row_t *row_ids, Node &node, KeySe // increment the depth until we reach a leaf or find a mismatching byte auto prefix_start = key_section.depth; - while (start_key.len != key_section.depth && start_key.ByteMatches(end_key, key_section.depth)) { + while (start_key.len != key_section.depth && + start_key.ByteMatches(end_key, UnsafeNumericCast(key_section.depth))) { key_section.depth++; } @@ -140656,7 +141815,8 @@ bool Construct(ART &art, vector &keys, row_t *row_ids, Node &node, KeySe } reference ref_node(node); - Prefix::New(art, ref_node, start_key, prefix_start, start_key.len - prefix_start); + Prefix::New(art, ref_node, start_key, UnsafeNumericCast(prefix_start), + UnsafeNumericCast(start_key.len - prefix_start)); if (single_row_id) { Leaf::New(ref_node, row_ids[key_section.start]); } else { @@ -140674,7 +141834,8 @@ bool Construct(ART &art, vector &keys, row_t *row_ids, Node &node, KeySe // set the prefix reference ref_node(node); auto prefix_length = key_section.depth - prefix_start; - Prefix::New(art, ref_node, start_key, prefix_start, prefix_length); + Prefix::New(art, ref_node, start_key, UnsafeNumericCast(prefix_start), + UnsafeNumericCast(prefix_length)); // set the node auto node_type = Node::GetARTNodeTypeByCount(child_sections.size()); @@ -140815,7 +141976,8 @@ bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id if (!node.HasMetadata()) { D_ASSERT(depth <= key.len); reference ref_node(node); - Prefix::New(*this, ref_node, key, depth, key.len - depth); + Prefix::New(*this, ref_node, key, UnsafeNumericCast(depth), + UnsafeNumericCast(key.len - depth)); Leaf::New(ref_node, row_id); return true; } @@ -140842,7 +142004,8 @@ bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id Node leaf_node; reference ref_node(leaf_node); if (depth + 1 < key.len) { - Prefix::New(*this, ref_node, key, depth + 1, key.len - depth - 1); + Prefix::New(*this, ref_node, key, UnsafeNumericCast(depth + 1), + UnsafeNumericCast(key.len - depth - 1)); } Leaf::New(ref_node, row_id); Node::InsertChild(*this, node, key[depth], leaf_node); @@ -140872,7 +142035,8 @@ bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id Node leaf_node; reference ref_node(leaf_node); if (depth + 1 < key.len) { - Prefix::New(*this, ref_node, key, depth + 1, key.len - depth - 1); + Prefix::New(*this, ref_node, key, UnsafeNumericCast(depth + 1), + UnsafeNumericCast(key.len - depth - 1)); } Leaf::New(ref_node, row_id); Node4::InsertChild(*this, next_node, key[depth], leaf_node); @@ -141566,12 +142730,12 @@ ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, } // end with a null-terminator data[pos] = '\0'; - return ARTKey(data, len); + return ARTKey(data, UnsafeNumericCast(len)); } template <> ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, const char *value) { - return ARTKey::CreateARTKey(allocator, type, string_t(value, strlen(value))); + return ARTKey::CreateARTKey(allocator, type, string_t(value, UnsafeNumericCast(strlen(value)))); } template <> @@ -141581,7 +142745,7 @@ void ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, AR template <> void ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, ARTKey &key, const char *value) { - ARTKey::CreateARTKey(allocator, type, key, string_t(value, strlen(value))); + ARTKey::CreateARTKey(allocator, type, key, string_t(value, UnsafeNumericCast(strlen(value)))); } bool ARTKey::operator>(const ARTKey &k) const { @@ -141865,7 +143029,7 @@ void Leaf::New(ART &art, reference &node, const row_t *row_ids, idx_t coun auto &leaf = Node::RefMutable(art, node, NType::LEAF); - leaf.count = MinValue((idx_t)Node::LEAF_SIZE, count); + leaf.count = UnsafeNumericCast(MinValue((idx_t)Node::LEAF_SIZE, count)); for (idx_t i = 0; i < leaf.count; i++) { leaf.row_ids[i] = row_ids[copy_count + i]; @@ -142756,7 +143920,7 @@ Node16 &Node16::ShrinkNode48(ART &art, Node &node16, Node &node48) { for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) { D_ASSERT(n16.count <= Node::NODE_16_CAPACITY); if (n48.child_index[i] != Node::EMPTY_MARKER) { - n16.key[n16.count] = i; + n16.key[n16.count] = UnsafeNumericCast(i); n16.children[n16.count] = n48.children[n48.child_index[i]]; n16.count++; } @@ -143010,7 +144174,7 @@ optional_ptr Node256::GetChildMutable(const uint8_t byte) { optional_ptr Node256::GetNextChild(uint8_t &byte) const { for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) { if (children[i].HasMetadata()) { - byte = i; + byte = UnsafeNumericCast(i); return &children[i]; } } @@ -143020,7 +144184,7 @@ optional_ptr Node256::GetNextChild(uint8_t &byte) const { optional_ptr Node256::GetNextChildMutable(uint8_t &byte) { for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) { if (children[i].HasMetadata()) { - byte = i; + byte = UnsafeNumericCast(i); return &children[i]; } } @@ -143278,7 +144442,7 @@ Node48 &Node48::GrowNode16(ART &art, Node &node48, Node &node16) { } for (idx_t i = 0; i < n16.count; i++) { - n48.child_index[n16.key[i]] = i; + n48.child_index[n16.key[i]] = UnsafeNumericCast(i); n48.children[i] = n16.children[i]; } @@ -143348,7 +144512,7 @@ void Node48::InsertChild(ART &art, Node &node, const uint8_t byte, const Node ch } } n48.children[child_pos] = child; - n48.child_index[byte] = child_pos; + n48.child_index[byte] = UnsafeNumericCast(child_pos); n48.count++; } else { @@ -143395,7 +144559,7 @@ optional_ptr Node48::GetChildMutable(const uint8_t byte) { optional_ptr Node48::GetNextChild(uint8_t &byte) const { for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) { if (child_index[i] != Node::EMPTY_MARKER) { - byte = i; + byte = UnsafeNumericCast(i); D_ASSERT(children[child_index[i]].HasMetadata()); return &children[child_index[i]]; } @@ -143406,7 +144570,7 @@ optional_ptr Node48::GetNextChild(uint8_t &byte) const { optional_ptr Node48::GetNextChildMutable(uint8_t &byte) { for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) { if (child_index[i] != Node::EMPTY_MARKER) { - byte = i; + byte = UnsafeNumericCast(i); D_ASSERT(children[child_index[i]].HasMetadata()); return &children[child_index[i]]; } @@ -143699,7 +144863,7 @@ void Prefix::Split(ART &art, reference &prefix_node, Node &child_node, idx } // set the new size of this node - prefix.data[Node::PREFIX_SIZE] = position; + prefix.data[Node::PREFIX_SIZE] = UnsafeNumericCast(position); // no bytes left before the split, free this node if (position == 0) { @@ -144242,7 +145406,8 @@ void FixedSizeBuffer::Serialize(PartialBlockManager &partial_block_manager, cons D_ASSERT(InMemory() && !OnDisk()); // now we write the changes, first get a partial block allocation - PartialBlockAllocation allocation = partial_block_manager.GetBlockAllocation(allocation_size); + PartialBlockAllocation allocation = + partial_block_manager.GetBlockAllocation(NumericCast(allocation_size)); block_pointer.block_id = allocation.state.block_id; block_pointer.offset = allocation.state.offset; @@ -144293,7 +145458,7 @@ void FixedSizeBuffer::Pin() { Destroy(); buffer_handle = std::move(new_buffer_handle); - block_handle = new_block_handle; + block_handle = std::move(new_block_handle); block_pointer = BlockPointer(); } @@ -144307,7 +145472,7 @@ uint32_t FixedSizeBuffer::GetOffset(const idx_t bitmask_count) { // fills up a buffer sequentially before searching for free bits if (mask.RowIsValid(segment_count)) { mask.SetInvalid(segment_count); - return segment_count; + return UnsafeNumericCast(segment_count); } for (idx_t entry_idx = 0; entry_idx < bitmask_count; entry_idx++) { @@ -144340,7 +145505,7 @@ uint32_t FixedSizeBuffer::GetOffset(const idx_t bitmask_count) { auto prev_bits = entry_idx * sizeof(validity_t) * 8; D_ASSERT(mask.RowIsValid(prev_bits + first_valid_bit)); mask.SetInvalid(prev_bits + first_valid_bit); - return (prev_bits + first_valid_bit); + return UnsafeNumericCast(prev_bits + first_valid_bit); } throw InternalException("Invalid bitmask for FixedSizeAllocator"); @@ -144367,7 +145532,7 @@ uint32_t FixedSizeBuffer::GetMaxOffset(const idx_t available_segments) { if (available_segments % entry_size != 0) { bitmask_count++; } - uint32_t max_offset = bitmask_count * sizeof(validity_t) * 8; + auto max_offset = UnsafeNumericCast(bitmask_count * sizeof(validity_t) * 8); auto bits_in_last_entry = available_segments % (sizeof(validity_t) * 8); // get the bitmask data @@ -146497,7 +147662,7 @@ AggregateObject::AggregateObject(BoundWindowExpression &window) vector AggregateObject::CreateAggregateObjects(const vector &bindings) { vector aggregates; - aggregates.reserve(aggregates.size()); + aggregates.reserve(bindings.size()); for (auto &binding : bindings) { aggregates.emplace_back(binding); } @@ -146907,6 +148072,7 @@ class ThreadContext { + namespace duckdb { HashAggregateGroupingData::HashAggregateGroupingData(GroupingSet &grouping_set_p, @@ -147369,7 +148535,7 @@ class HashAggregateFinalizeTask : public ExecutorTask { public: HashAggregateFinalizeTask(ClientContext &context, Pipeline &pipeline, shared_ptr event_p, const PhysicalHashAggregate &op, HashAggregateGlobalSinkState &state_p) - : ExecutorTask(pipeline.executor), context(context), pipeline(pipeline), event(std::move(event_p)), op(op), + : ExecutorTask(pipeline.executor, std::move(event_p)), context(context), pipeline(pipeline), op(op), gstate(state_p) { } @@ -147379,7 +148545,6 @@ class HashAggregateFinalizeTask : public ExecutorTask { private: ClientContext &context; Pipeline &pipeline; - shared_ptr event; const PhysicalHashAggregate &op; HashAggregateGlobalSinkState &gstate; @@ -147430,7 +148595,7 @@ class HashAggregateDistinctFinalizeTask : public ExecutorTask { public: HashAggregateDistinctFinalizeTask(Pipeline &pipeline, shared_ptr event_p, const PhysicalHashAggregate &op, HashAggregateGlobalSinkState &state_p) - : ExecutorTask(pipeline.executor), pipeline(pipeline), event(std::move(event_p)), op(op), gstate(state_p) { + : ExecutorTask(pipeline.executor, std::move(event_p)), pipeline(pipeline), op(op), gstate(state_p) { } public: @@ -147441,7 +148606,6 @@ class HashAggregateDistinctFinalizeTask : public ExecutorTask { private: Pipeline &pipeline; - shared_ptr event; const PhysicalHashAggregate &op; HashAggregateGlobalSinkState &gstate; @@ -148348,7 +149512,6 @@ OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, D GlobalOperatorState &gstate_p, OperatorState &state_p) const { auto &gstate = gstate_p.Cast(); auto &state = state_p.Cast(); - state.allocator.Reset(); if (!state.initialized) { state.Initialize(context.client, input, select_list); @@ -148546,6 +149709,7 @@ class PhysicalUngroupedAggregate : public PhysicalOperator { + #include namespace duckdb { @@ -148933,8 +150097,8 @@ class UngroupedDistinctAggregateFinalizeTask : public ExecutorTask { UngroupedDistinctAggregateFinalizeTask(Executor &executor, shared_ptr event_p, const PhysicalUngroupedAggregate &op, UngroupedAggregateGlobalSinkState &state_p) - : ExecutorTask(executor), event(std::move(event_p)), op(op), gstate(state_p), - allocator(gstate.CreateAllocator()), aggregate_state(op.aggregates) { + : ExecutorTask(executor, std::move(event_p)), op(op), gstate(state_p), allocator(gstate.CreateAllocator()), + aggregate_state(op.aggregates) { } TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override; @@ -148943,8 +150107,6 @@ class UngroupedDistinctAggregateFinalizeTask : public ExecutorTask { TaskExecutionResult AggregateDistinct(); private: - shared_ptr event; - const PhysicalUngroupedAggregate &op; UngroupedAggregateGlobalSinkState &gstate; @@ -149325,7 +150487,7 @@ class WindowAggregatorState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -149561,6 +150723,7 @@ struct WindowInputExpression { chunk.Reset(); executor.Execute(input_chunk, chunk); chunk.Verify(); + chunk.Flatten(); } } @@ -149647,7 +150810,7 @@ class WindowExecutorState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -150629,7 +151792,7 @@ bool CSVBuffer::IsCSVFileLastBuffer() { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.hpp +// duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp // // //===----------------------------------------------------------------------===// @@ -150724,7 +151887,7 @@ class CSVBufferManager { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/table_function/csv_file_scanner.hpp +// duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp // // //===----------------------------------------------------------------------===// @@ -150735,7 +151898,7 @@ class CSVBufferManager { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/scanner/scanner_boundary.hpp +// duckdb/execution/operator/csv_scanner/scanner_boundary.hpp // // //===----------------------------------------------------------------------===// @@ -150748,7 +151911,7 @@ class CSVBufferManager { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine.hpp +// duckdb/execution/operator/csv_scanner/csv_state_machine.hpp // // //===----------------------------------------------------------------------===// @@ -150929,7 +152092,7 @@ struct CSVIterator { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/util/csv_error.hpp +// duckdb/execution/operator/csv_scanner/csv_error.hpp // // //===----------------------------------------------------------------------===// @@ -150955,6 +152118,13 @@ 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 { @@ -150965,30 +152135,39 @@ enum CSVErrorType : uint8_t { SNIFFING = 4, // If something went wrong during sniffing and was not possible to find suitable candidates MAXIMUM_LINE_SIZE = 5, // Maximum line size was exceeded by a line in the CSV File NULLPADDED_QUOTED_NEW_VALUE = 6, // If the null_padding option is set and we have quoted new values in parallel + INVALID_UNICODE = 7 }; class CSVError { public: - CSVError(string error_message, CSVErrorType type, idx_t column_idx, vector row); - CSVError(string error_message, CSVErrorType type); + CSVError() {}; + CSVError(string error_message, CSVErrorType type, idx_t column_idx, vector row, LinesPerBoundary error_info); + CSVError(string error_message, CSVErrorType type, LinesPerBoundary error_info); //! 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, - idx_t column_idx, vector &row); + idx_t column_idx, vector &row, LinesPerBoundary error_info, LogicalTypeId type); //! Produces error for when the line size exceeds the maximum line size option - static CSVError LineSizeError(const CSVReaderOptions &options, idx_t actual_size); + static CSVError LineSizeError(const CSVReaderOptions &options, idx_t actual_size, LinesPerBoundary error_info); //! Produces error for when the sniffer couldn't find viable options static CSVError SniffingError(string &file_path); //! Produces error messages for unterminated quoted values static CSVError UnterminatedQuotesError(const CSVReaderOptions &options, string_t *vector_ptr, - idx_t vector_line_start, idx_t current_column); + idx_t vector_line_start, idx_t current_column, LinesPerBoundary error_info); //! Produces error messages for null_padding option is set and we have quoted new values in parallel - static CSVError NullPaddingFail(const CSVReaderOptions &options); + static CSVError NullPaddingFail(const CSVReaderOptions &options, LinesPerBoundary error_info); //! Produces error for incorrect (e.g., smaller and lower than the predefined) number of columns in a CSV Line static CSVError IncorrectColumnAmountError(const CSVReaderOptions &options, string_t *vector_ptr, - idx_t vector_line_start, idx_t actual_columns); + idx_t vector_line_start, idx_t actual_columns, + LinesPerBoundary error_info); + //! Produces error message when we detect an invalid utf-8 value + static CSVError InvalidUTF8(const CSVReaderOptions &options, LinesPerBoundary error_info); + idx_t GetBoundaryIndex() { + return error_info.boundary_idx; + } + //! Actual error message string error_message; //! Error Type @@ -150997,36 +152176,46 @@ class CSVError { idx_t column_idx; //! Values from the row where error happened vector row; + //! Line information regarding this error + LinesPerBoundary error_info; }; class CSVErrorHandler { public: CSVErrorHandler(bool ignore_errors = false); //! Throws the error - void Error(LinesPerBoundary &error_info, CSVError &csv_error, bool force_error = false); - //! Throws the error - void Error(CSVError &csv_error); + void Error(CSVError csv_error, bool force_error = false); + //! If we have a cached error, and we can now error, we error. + void ErrorIfNeeded(); //! Inserts a finished error info void Insert(idx_t boundary_idx, idx_t rows); - vector> errors; + //! Method that actually throws the error + void ThrowError(CSVError csv_error); + //! If we processed all boundaries before the one that error-ed + bool CanGetLine(idx_t boundary_index); //! Return the 1-indexed line number - idx_t GetLine(LinesPerBoundary &error_info); + idx_t GetLine(const LinesPerBoundary &error_info); void NewMaxLineSize(idx_t scan_line_size); + //! Set of errors + map> errors; + idx_t GetMaxLineLength() { return max_line_length; } + void DontPrintErrorLine() { + print_line = false; + } private: //! If we should print the line of an error bool PrintLineNumber(CSVError &error); //! CSV Error Handler Mutex mutex main_mutex; - //! Map of -> lines + //! Map of -> lines read unordered_map lines_per_batch_map; idx_t max_line_length = 0; bool ignore_errors = false; - - bool got_borked = false; + bool print_line = true; }; } // namespace duckdb @@ -151150,6 +152339,8 @@ struct ReadCSVData : public BaseCSVData { vector csv_types; //! The expected SQL names to be read from the file vector csv_names; + //! If the sql types from the file were manually set + vector manually_set; //! The expected SQL types to be returned from the read - including added constants (e.g. filename, hive partitions) vector return_types; //! The expected SQL names to be returned from the read - including added constants (e.g. filename, hive partitions) @@ -151266,7 +152457,12 @@ shared_ptr CSVBufferManager::GetBuffer(const idx_t pos) { } void CSVBufferManager::ResetBuffer(const idx_t buffer_idx) { - D_ASSERT(buffer_idx < cached_buffers.size() && cached_buffers[buffer_idx]); + lock_guard parallel_lock(main_mutex); + if (buffer_idx >= cached_buffers.size()) { + // Nothing to reset + return; + } + D_ASSERT(cached_buffers[buffer_idx]); if (buffer_idx == 0 && cached_buffers.size() > 1) { cached_buffers[buffer_idx].reset(); idx_t cur_buffer = buffer_idx + 1; @@ -151408,7 +152604,7 @@ string CSVFileHandle::GetFilePath() { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp +// duckdb/execution/operator/csv_scanner/csv_sniffer.hpp // // //===----------------------------------------------------------------------===// @@ -151421,7 +152617,7 @@ string CSVFileHandle::GetFilePath() { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/scanner/column_count_scanner.hpp +// duckdb/execution/operator/csv_scanner/column_count_scanner.hpp // // //===----------------------------------------------------------------------===// @@ -151434,7 +152630,7 @@ string CSVFileHandle::GetFilePath() { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/scanner/string_value_scanner.hpp +// duckdb/execution/operator/csv_scanner/string_value_scanner.hpp // // //===----------------------------------------------------------------------===// @@ -151447,7 +152643,7 @@ string CSVFileHandle::GetFilePath() { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/scanner/base_scanner.hpp +// duckdb/execution/operator/csv_scanner/base_scanner.hpp // // //===----------------------------------------------------------------------===// @@ -151459,6 +152655,7 @@ string CSVFileHandle::GetFilePath() { + namespace duckdb { class CSVFileScan; @@ -151492,8 +152689,8 @@ class ScannerResult { class BaseScanner { public: explicit BaseScanner(shared_ptr buffer_manager, shared_ptr state_machine, - shared_ptr error_handler, shared_ptr csv_file_scan = nullptr, - CSVIterator iterator = {}); + shared_ptr error_handler, bool sniffing = false, + shared_ptr csv_file_scan = nullptr, CSVIterator iterator = {}); virtual ~BaseScanner() = default; //! Returns true if the scanner is finished @@ -151535,6 +152732,8 @@ class BaseScanner { //! States CSVStates states; + bool ever_quoted = false; + protected: //! Boundaries of this scanner CSVIterator iterator; @@ -151558,6 +152757,10 @@ class BaseScanner { //! Initializes the scanner virtual void Initialize(); + inline bool ContainsZeroByte(uint64_t v) { + return (v - UINT64_C(0x0101010101010101)) & ~(v)&UINT64_C(0x8080808080808080); + } + //! Process one chunk template void Process(T &result) { @@ -151581,67 +152784,94 @@ class BaseScanner { return; case CSVState::RECORD_SEPARATOR: if (states.states[0] == CSVState::RECORD_SEPARATOR || states.states[0] == CSVState::NOT_SET) { - lines_read++; if (T::EmptyLine(result, iterator.pos.buffer_pos)) { iterator.pos.buffer_pos++; bytes_read = iterator.pos.buffer_pos - start_pos; + lines_read++; return; } - } else if (states.states[0] != CSVState::CARRIAGE_RETURN) { lines_read++; + + } else if (states.states[0] != CSVState::CARRIAGE_RETURN) { if (T::AddRow(result, iterator.pos.buffer_pos)) { iterator.pos.buffer_pos++; bytes_read = iterator.pos.buffer_pos - start_pos; + lines_read++; return; } + lines_read++; } iterator.pos.buffer_pos++; break; case CSVState::CARRIAGE_RETURN: - lines_read++; if (states.states[0] == CSVState::RECORD_SEPARATOR || states.states[0] == CSVState::NOT_SET) { if (T::EmptyLine(result, iterator.pos.buffer_pos)) { iterator.pos.buffer_pos++; bytes_read = iterator.pos.buffer_pos - start_pos; + lines_read++; return; } } else if (states.states[0] != CSVState::CARRIAGE_RETURN) { if (T::AddRow(result, iterator.pos.buffer_pos)) { iterator.pos.buffer_pos++; bytes_read = iterator.pos.buffer_pos - start_pos; + lines_read++; return; } } iterator.pos.buffer_pos++; + lines_read++; break; case CSVState::DELIMITER: T::AddValue(result, iterator.pos.buffer_pos); iterator.pos.buffer_pos++; break; - case CSVState::QUOTED: + case CSVState::QUOTED: { if (states.states[0] == CSVState::UNQUOTED) { 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 = + Load(reinterpret_cast(&buffer_handle_ptr[iterator.pos.buffer_pos])); + if (ContainsZeroByte((value ^ state_machine->transition_array.quote) & + (value ^ state_machine->transition_array.escape))) { + break; + } + iterator.pos.buffer_pos += 8; + } + while (state_machine->transition_array .skip_quoted[static_cast(buffer_handle_ptr[iterator.pos.buffer_pos])] && iterator.pos.buffer_pos < to_pos - 1) { iterator.pos.buffer_pos++; } - break; + } break; case CSVState::ESCAPE: T::SetEscaped(result); iterator.pos.buffer_pos++; break; - case CSVState::STANDARD: + case CSVState::STANDARD: { iterator.pos.buffer_pos++; + while (iterator.pos.buffer_pos + 8 < to_pos) { + uint64_t value = + Load(reinterpret_cast(&buffer_handle_ptr[iterator.pos.buffer_pos])); + if (ContainsZeroByte((value ^ state_machine->transition_array.delimiter) & + (value ^ state_machine->transition_array.new_line) & + (value ^ state_machine->transition_array.carriage_return))) { + break; + } + iterator.pos.buffer_pos += 8; + } while (state_machine->transition_array .skip_standard[static_cast(buffer_handle_ptr[iterator.pos.buffer_pos])] && iterator.pos.buffer_pos < to_pos - 1) { iterator.pos.buffer_pos++; } break; + } case CSVState::QUOTED_NEW_LINE: T::QuotedNewLine(result); iterator.pos.buffer_pos++; @@ -151713,7 +152943,9 @@ class StringValueResult : public ScannerResult { StringValueResult(CSVStates &states, CSVStateMachine &state_machine, const shared_ptr &buffer_handle, Allocator &buffer_allocator, idx_t result_size, idx_t buffer_position, CSVErrorHandler &error_hander, CSVIterator &iterator, bool store_line_size, - shared_ptr csv_file_scan, idx_t &lines_read); + shared_ptr csv_file_scan, idx_t &lines_read, bool sniffing); + + ~StringValueResult(); //! Information on the vector unsafe_vector vector_ptr; @@ -151746,7 +152978,7 @@ class StringValueResult : public ScannerResult { bool added_last_line = false; bool quoted_new_line = false; - unsafe_unique_array parse_types; + unsafe_unique_array> parse_types; vector names; unordered_map cast_errors; @@ -151762,6 +152994,8 @@ class StringValueResult : public ScannerResult { //! If the current row has an error, we have to skip it bool ignore_current_row = false; + + bool sniffing; //! Specialized code for quoted values, makes sure to remove quotes and escapes static inline void AddQuotedValue(StringValueResult &result, const idx_t buffer_pos); //! Adds a Value to the result @@ -151784,7 +153018,6 @@ class StringValueResult : public ScannerResult { Value GetValue(idx_t row_idx, idx_t col_idx); DataChunk &ToChunk(); - //! Resets the state of the result void Reset(); }; @@ -151795,7 +153028,7 @@ class StringValueScanner : public BaseScanner { StringValueScanner(idx_t scanner_idx, const shared_ptr &buffer_manager, const shared_ptr &state_machine, const shared_ptr &error_handler, const shared_ptr &csv_file_scan, - CSVIterator boundary = {}, idx_t result_size = STANDARD_VECTOR_SIZE); + bool sniffing = false, CSVIterator boundary = {}, idx_t result_size = STANDARD_VECTOR_SIZE); StringValueScanner(const shared_ptr &buffer_manager, const shared_ptr &state_machine, @@ -152044,7 +153277,8 @@ class CSVSniffer { void DetectTypes(); //! Change the date format for the type to the string //! Try to cast a string value to the specified sql type - bool TryCastValue(CSVStateMachine &candidate, const Value &value, const LogicalType &sql_type); + bool TryCastValue(const DialectOptions &dialect_options, const string &decimal_separator, const Value &value, + const LogicalType &sql_type); void SetDateFormat(CSVStateMachine &candidate, const string &format_specifier, const LogicalTypeId &sql_type); //! Function that initialized the necessary variables used for date and timestamp detection @@ -152075,17 +153309,18 @@ class CSVSniffer { void RefineTypes(); bool TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type); vector detected_types; - //! ------------------------------------------------------// //! ------------------ Header Detection ----------------- // //! ------------------------------------------------------// void DetectHeader(); + bool DetectHeaderWithSetColumn(); vector names; //! ------------------------------------------------------// //! ------------------ Type Replacement ----------------- // //! ------------------------------------------------------// void ReplaceTypes(); + vector manually_set; }; } // namespace duckdb @@ -152099,9 +153334,9 @@ ScannerResult::ScannerResult(CSVStates &states_p, CSVStateMachine &state_machine } BaseScanner::BaseScanner(shared_ptr buffer_manager_p, shared_ptr state_machine_p, - shared_ptr error_handler_p, shared_ptr csv_file_scan_p, - CSVIterator iterator_p) - : csv_file_scan(std::move(csv_file_scan_p)), error_handler(std::move(error_handler_p)), + shared_ptr error_handler_p, bool sniffing_p, + shared_ptr csv_file_scan_p, CSVIterator iterator_p) + : csv_file_scan(std::move(csv_file_scan_p)), sniffing(sniffing_p), error_handler(std::move(error_handler_p)), state_machine(std::move(state_machine_p)), iterator(iterator_p), buffer_manager(std::move(buffer_manager_p)) { D_ASSERT(buffer_manager); D_ASSERT(state_machine); @@ -152212,8 +153447,7 @@ ColumnCountScanner::ColumnCountScanner(shared_ptr buffer_manag } unique_ptr ColumnCountScanner::UpgradeToStringValueScanner() { - auto scanner = make_uniq(0, buffer_manager, state_machine, error_handler, nullptr); - scanner->sniffing = true; + auto scanner = make_uniq(0, buffer_manager, state_machine, error_handler, nullptr, true); return scanner; } @@ -152290,17 +153524,21 @@ CSVIterator::CSVIterator() : is_set(false) { } void CSVBoundary::Print() { +#ifndef DUCKDB_DISABLE_PRINT std::cout << "---Boundary: " << boundary_idx << " ---" << std::endl; std::cout << "File Index:: " << file_idx << std::endl; std::cout << "Buffer Index: " << buffer_idx << std::endl; std::cout << "Buffer Pos: " << buffer_pos << std::endl; std::cout << "End Pos: " << end_pos << std::endl; std::cout << "------------" << end_pos << std::endl; +#endif } void CSVIterator::Print() { +#ifndef DUCKDB_DISABLE_PRINT boundary.Print(); std::cout << "Is set: " << is_set << std::endl; +#endif } bool CSVIterator::Next(CSVBufferManager &buffer_manager) { @@ -152366,7 +153604,7 @@ void CSVIterator::SetStart(idx_t start) { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/scanner/skip_scanner.hpp +// duckdb/execution/operator/csv_scanner/skip_scanner.hpp // // //===----------------------------------------------------------------------===// @@ -152490,7 +153728,7 @@ void SkipScanner::FinalizeChunkProcess() { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/util/csv_casting.hpp +// duckdb/execution/operator/csv_scanner/csv_casting.hpp // // //===----------------------------------------------------------------------===// @@ -152506,14 +153744,14 @@ namespace duckdb { class CSVCast { template static bool TemplatedTryCastFloatingVector(const CSVReaderOptions &options, Vector &input_vector, - Vector &result_vector, idx_t count, string &error_message, + Vector &result_vector, idx_t count, CastParameters ¶meters, idx_t &line_error) { D_ASSERT(input_vector.GetType().id() == LogicalTypeId::VARCHAR); bool all_converted = true; idx_t row = 0; UnaryExecutor::Execute(input_vector, result_vector, count, [&](string_t input) { T result; - if (!OP::Operation(input, result, &error_message)) { + if (!OP::Operation(input, result, parameters)) { line_error = row; all_converted = false; } else { @@ -152526,14 +153764,23 @@ class CSVCast { template static bool TemplatedTryCastDecimalVector(const CSVReaderOptions &options, Vector &input_vector, - Vector &result_vector, idx_t count, string &error_message, uint8_t width, - uint8_t scale) { + Vector &result_vector, idx_t count, CastParameters ¶meters, + uint8_t width, uint8_t scale, idx_t &line_error) { D_ASSERT(input_vector.GetType().id() == LogicalTypeId::VARCHAR); bool all_converted = true; + auto &validity_mask = FlatVector::Validity(result_vector); + idx_t cur_line = 0; UnaryExecutor::Execute(input_vector, result_vector, count, [&](string_t input) { T result; - if (!OP::Operation(input, result, &error_message, width, scale)) { + if (!OP::Operation(input, result, parameters, width, scale)) { + if (all_converted) { + line_error = cur_line; + } + validity_mask.SetInvalid(cur_line); all_converted = false; + cur_line++; + } else { + cur_line++; } return result; }); @@ -152557,14 +153804,20 @@ class CSVCast { template static bool TemplatedTryCastDateVector(const map> &options, Vector &input_vector, Vector &result_vector, idx_t count, - string &error_message, idx_t &line_error) { + CastParameters ¶meters, idx_t &line_error, bool nullify_error) { D_ASSERT(input_vector.GetType().id() == LogicalTypeId::VARCHAR); bool all_converted = true; idx_t cur_line = 0; + auto &validity_mask = FlatVector::Validity(result_vector); UnaryExecutor::Execute(input_vector, result_vector, count, [&](string_t input) { T result; - if (!OP::Operation(options, input, result, error_message)) { - line_error = cur_line; + if (!OP::Operation(options, input, result, *parameters.error_message)) { + if (all_converted) { + line_error = cur_line; + } + if (nullify_error) { + validity_mask.SetInvalid(cur_line); + } all_converted = false; } cur_line++; @@ -152575,49 +153828,51 @@ class CSVCast { public: static bool TryCastDateVector(const map> &options, Vector &input_vector, - Vector &result_vector, idx_t count, string &error_message, idx_t &line_error) { + Vector &result_vector, idx_t count, CastParameters ¶meters, idx_t &line_error, + bool nullify_error = false) { return TemplatedTryCastDateVector(options, input_vector, result_vector, count, - error_message, line_error); + parameters, line_error, nullify_error); } static bool TryCastTimestampVector(const map> &options, Vector &input_vector, Vector &result_vector, idx_t count, - string &error_message) { + CastParameters ¶meters, bool nullify_error = false) { idx_t line_error; - return TemplatedTryCastDateVector(options, input_vector, result_vector, - count, error_message, line_error); + return TemplatedTryCastDateVector( + options, input_vector, result_vector, count, parameters, line_error, nullify_error); } static bool TryCastFloatingVectorCommaSeparated(const CSVReaderOptions &options, Vector &input_vector, - Vector &result_vector, idx_t count, string &error_message, + Vector &result_vector, idx_t count, CastParameters ¶meters, const LogicalType &result_type, idx_t &line_error) { switch (result_type.InternalType()) { case PhysicalType::DOUBLE: return TemplatedTryCastFloatingVector( - options, input_vector, result_vector, count, error_message, line_error); + options, input_vector, result_vector, count, parameters, line_error); case PhysicalType::FLOAT: return TemplatedTryCastFloatingVector( - options, input_vector, result_vector, count, error_message, line_error); + options, input_vector, result_vector, count, parameters, line_error); default: throw InternalException("Unimplemented physical type for floating"); } } + static bool TryCastDecimalVectorCommaSeparated(const CSVReaderOptions &options, Vector &input_vector, - Vector &result_vector, idx_t count, string &error_message, - const LogicalType &result_type) { + Vector &result_vector, idx_t count, CastParameters ¶meters, + const LogicalType &result_type, idx_t &line_error) { auto width = DecimalType::GetWidth(result_type); auto scale = DecimalType::GetScale(result_type); switch (result_type.InternalType()) { case PhysicalType::INT16: return TemplatedTryCastDecimalVector( - options, input_vector, result_vector, count, error_message, width, scale); + options, input_vector, result_vector, count, parameters, width, scale, line_error); case PhysicalType::INT32: return TemplatedTryCastDecimalVector( - options, input_vector, result_vector, count, error_message, width, scale); + options, input_vector, result_vector, count, parameters, width, scale, line_error); case PhysicalType::INT64: return TemplatedTryCastDecimalVector( - options, input_vector, result_vector, count, error_message, width, scale); + options, input_vector, result_vector, count, parameters, width, scale, line_error); case PhysicalType::INT128: return TemplatedTryCastDecimalVector( - options, input_vector, result_vector, count, error_message, width, scale); + options, input_vector, result_vector, count, parameters, width, scale, line_error); default: throw InternalException("Unimplemented physical type for decimal"); } @@ -152632,18 +153887,21 @@ class CSVCast { #include + namespace duckdb { 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) - : ScannerResult(states, state_machine), number_of_columns(state_machine.dialect_options.num_cols), + shared_ptr csv_file_scan_p, idx_t &lines_read_p, bool sniffing_p) + : ScannerResult(states, state_machine), + number_of_columns(NumericCast(state_machine.dialect_options.num_cols)), null_padding(state_machine.options.null_padding), ignore_errors(state_machine.options.ignore_errors), null_str_ptr(state_machine.options.null_str.c_str()), null_str_size(state_machine.options.null_str.size()), result_size(result_size_p), 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) { + store_line_size(store_line_size_p), csv_file_scan(std::move(csv_file_scan_p)), lines_read(lines_read_p), + sniffing(sniffing_p) { // Vector information D_ASSERT(number_of_columns > 0); buffer_handles.push_back(buffer_handle); @@ -152657,10 +153915,10 @@ StringValueResult::StringValueResult(CSVStates &states, CSVStateMachine &state_m pre_previous_line_start = previous_line_start; // Fill out Parse Types vector logical_types; - parse_types = make_unsafe_uniq_array(number_of_columns); + parse_types = make_unsafe_uniq_array>(number_of_columns); if (!csv_file_scan) { for (idx_t i = 0; i < number_of_columns; i++) { - parse_types[i] = LogicalTypeId::VARCHAR; + parse_types[i] = {LogicalTypeId::VARCHAR, true}; logical_types.emplace_back(LogicalType::VARCHAR); string name = "Column_" + to_string(i); names.emplace_back(name); @@ -152674,10 +153932,10 @@ StringValueResult::StringValueResult(CSVStates &states, CSVStateMachine &state_m for (idx_t i = 0; i < csv_file_scan->file_types.size(); i++) { auto &type = csv_file_scan->file_types[i]; if (StringValueScanner::CanDirectlyCast(type, state_machine.options.dialect_options.date_format)) { - parse_types[i] = type.id(); + parse_types[i] = {type.id(), true}; logical_types.emplace_back(type); } else { - parse_types[i] = LogicalTypeId::VARCHAR; + parse_types[i] = {LogicalTypeId::VARCHAR, type.id() == LogicalTypeId::VARCHAR || type.IsNested()}; logical_types.emplace_back(LogicalType::VARCHAR); } } @@ -152698,7 +153956,7 @@ StringValueResult::StringValueResult(CSVStates &states, CSVStateMachine &state_m if (!projecting_columns) { for (idx_t j = logical_types.size(); j < number_of_columns; j++) { // This can happen if we have sneaky null columns at the end that we wish to ignore - parse_types[j] = LogicalTypeId::VARCHAR; + parse_types[j] = {LogicalTypeId::VARCHAR, true}; logical_types.emplace_back(LogicalType::VARCHAR); } } @@ -152712,6 +153970,16 @@ StringValueResult::StringValueResult(CSVStates &states, CSVStateMachine &state_m } } +StringValueResult::~StringValueResult() { + // We have to insert the lines read by this scanner + error_handler.Insert(iterator.GetBoundaryIdx(), lines_read); + if (!iterator.done) { + // Some operators, like Limit, might cause a future error to incorrectly report the wrong error line + // Better to print nothing to print something wrong + error_handler.DontPrintErrorLine(); + } +} + inline bool IsValueNull(const char *null_str_ptr, const char *value_ptr, const idx_t size) { for (idx_t i = 0; i < size; i++) { if (null_str_ptr[i] != value_ptr[i]) { @@ -152749,7 +154017,7 @@ void StringValueResult::AddValueToVector(const char *value_ptr, const idx_t size empty = state_machine.options.force_not_null[chunk_col_id]; } if (empty) { - if (parse_types[chunk_col_id] != LogicalTypeId::VARCHAR) { + if (parse_types[chunk_col_id].first != LogicalTypeId::VARCHAR) { // If it is not a varchar, empty values are not accepted, we must error. cast_errors[chunk_col_id] = std::string(""); } @@ -152768,7 +154036,7 @@ void StringValueResult::AddValueToVector(const char *value_ptr, const idx_t size } } bool success = true; - switch (parse_types[chunk_col_id]) { + switch (parse_types[chunk_col_id].first) { case LogicalTypeId::TINYINT: success = TrySimpleIntegerCast(value_ptr, size, static_cast(vector_ptr[chunk_col_id])[number_of_rows], false); @@ -152823,15 +154091,30 @@ void StringValueResult::AddValueToVector(const char *value_ptr, const idx_t size TimestampCastResult::SUCCESS; break; } - default: + default: { + // By default we add a string + // We only evaluate if a string is utf8 valid, if it's actually a varchar + if (parse_types[chunk_col_id].second && !Utf8Proc::IsValid(value_ptr, UnsafeNumericCast(size))) { + bool force_error = !state_machine.options.ignore_errors && sniffing; + // Invalid unicode, we must error + LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), lines_read); + auto csv_error = CSVError::InvalidUTF8(state_machine.options, lines_per_batch); + error_handler.Error(csv_error, force_error); + // If we got here, we are ingoring errors, hence we must ignore this line. + ignore_current_row = true; + break; + } if (allocate) { - static_cast(vector_ptr[chunk_col_id])[number_of_rows] = - StringVector::AddStringOrBlob(parse_chunk.data[chunk_col_id], string_t(value_ptr, size)); + // If it's a value produced over multiple buffers, we must allocate + static_cast(vector_ptr[chunk_col_id])[number_of_rows] = StringVector::AddStringOrBlob( + parse_chunk.data[chunk_col_id], string_t(value_ptr, UnsafeNumericCast(size))); } else { - static_cast(vector_ptr[chunk_col_id])[number_of_rows] = string_t(value_ptr, size); + static_cast(vector_ptr[chunk_col_id])[number_of_rows] = + string_t(value_ptr, UnsafeNumericCast(size)); } break; } + } if (!success) { // We had a casting error, we push it here because we can only error when finishing the line read. cast_errors[cur_col_id] = std::string(value_ptr, size); @@ -152867,6 +154150,7 @@ void StringValueResult::Reset() { v->SetAllValid(result_size); } buffer_handles.clear(); + ignore_current_row = false; } void StringValueResult::AddQuotedValue(StringValueResult &result, const idx_t buffer_pos) { @@ -152912,10 +154196,10 @@ void StringValueResult::AddValue(StringValueResult &result, const idx_t buffer_p } void StringValueResult::HandleOverLimitRows() { - auto csv_error = - CSVError::IncorrectColumnAmountError(state_machine.options, nullptr, number_of_columns, cur_col_id + 1); LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), number_of_rows + 1); - error_handler.Error(lines_per_batch, csv_error); + auto csv_error = CSVError::IncorrectColumnAmountError(state_machine.options, nullptr, number_of_columns, + cur_col_id + 1, lines_per_batch); + error_handler.Error(csv_error); // If we get here we need to remove the last line cur_col_id = 0; chunk_col_id = 0; @@ -152931,14 +154215,16 @@ void StringValueResult::NullPaddingQuotedNewlineCheck() { if (state_machine.options.null_padding && iterator.IsBoundarySet() && quoted_new_line && iterator.done) { // If we have null_padding set, we found a quoted new line, we are scanning the file in parallel and it's the // last row of this thread. - auto csv_error = CSVError::NullPaddingFail(state_machine.options); LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), number_of_rows + 1); - error_handler.Error(lines_per_batch, csv_error, true); + auto csv_error = CSVError::NullPaddingFail(state_machine.options, lines_per_batch); + error_handler.Error(csv_error); } } bool StringValueResult::AddRowInternal() { if (ignore_current_row) { + cur_col_id = 0; + chunk_col_id = 0; // An error occurred on this row, we are ignoring it and resetting our control flag ignore_current_row = false; return false; @@ -152960,12 +154246,14 @@ bool StringValueResult::AddRowInternal() { std::ostringstream error; // Casting Error Message error << "Could not convert string \"" << cast_error.second << "\" to \'" - << LogicalTypeIdToString(parse_types[cast_error.first]) << "\'"; + << LogicalTypeIdToString(parse_types[cast_error.first].first) << "\'"; auto error_string = error.str(); - auto csv_error = CSVError::CastError(state_machine.options, names[cast_error.first], error_string, - cast_error.first, row); - LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), lines_read - 1); - error_handler.Error(lines_per_batch, csv_error); + LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), lines_read); + + auto csv_error = + CSVError::CastError(state_machine.options, names[cast_error.first], error_string, cast_error.first, row, + lines_per_batch, parse_types[cast_error.first].first); + error_handler.Error(csv_error); } // If we got here it means we are ignoring errors, hence we need to signify to our result scanner to ignore this // row @@ -153003,10 +154291,10 @@ bool StringValueResult::AddRowInternal() { } } else { // If we are not null-padding this is an error - auto csv_error = - CSVError::IncorrectColumnAmountError(state_machine.options, nullptr, number_of_columns, cur_col_id); LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), number_of_rows + 1); - error_handler.Error(lines_per_batch, csv_error); + auto csv_error = CSVError::IncorrectColumnAmountError(state_machine.options, nullptr, number_of_columns, + cur_col_id, lines_per_batch); + error_handler.Error(csv_error); // If we are here we ignore_errors, so we delete this line number_of_rows--; } @@ -153030,9 +154318,9 @@ bool StringValueResult::AddRow(StringValueResult &result, const idx_t buffer_pos result.error_handler.NewMaxLineSize(current_line_size); } if (current_line_size > result.state_machine.options.maximum_line_size) { - auto csv_error = CSVError::LineSizeError(result.state_machine.options, current_line_size); LinesPerBoundary lines_per_batch(result.iterator.GetBoundaryIdx(), result.number_of_rows); - result.error_handler.Error(lines_per_batch, csv_error, true); + auto csv_error = CSVError::LineSizeError(result.state_machine.options, current_line_size, lines_per_batch); + result.error_handler.Error(csv_error); } result.pre_previous_line_start = result.previous_line_start; result.previous_line_start = current_line_start; @@ -153060,11 +154348,11 @@ bool StringValueResult::AddRow(StringValueResult &result, const idx_t buffer_pos void StringValueResult::InvalidState(StringValueResult &result) { // FIXME: How do we recover from an invalid state? Can we restart the state machine and jump to the next row? + LinesPerBoundary lines_per_batch(result.iterator.GetBoundaryIdx(), result.number_of_rows); auto csv_error = CSVError::UnterminatedQuotesError(result.state_machine.options, static_cast(result.vector_ptr[result.chunk_col_id]), - result.number_of_rows, result.cur_col_id); - LinesPerBoundary lines_per_batch(result.iterator.GetBoundaryIdx(), result.number_of_rows); - result.error_handler.Error(lines_per_batch, csv_error); + result.number_of_rows, result.cur_col_id, lines_per_batch); + result.error_handler.Error(csv_error); } bool StringValueResult::EmptyLine(StringValueResult &result, const idx_t buffer_pos) { @@ -153098,21 +154386,22 @@ bool StringValueResult::EmptyLine(StringValueResult &result, const idx_t buffer_ StringValueScanner::StringValueScanner(idx_t scanner_idx_p, const shared_ptr &buffer_manager, const shared_ptr &state_machine, const shared_ptr &error_handler, - const shared_ptr &csv_file_scan, CSVIterator boundary, - idx_t result_size) - : BaseScanner(buffer_manager, state_machine, error_handler, csv_file_scan, boundary), scanner_idx(scanner_idx_p), + const shared_ptr &csv_file_scan, bool sniffing, + CSVIterator boundary, idx_t result_size) + : BaseScanner(buffer_manager, state_machine, error_handler, sniffing, csv_file_scan, boundary), + scanner_idx(scanner_idx_p), result(states, *state_machine, cur_buffer_handle, BufferAllocator::Get(buffer_manager->context), result_size, iterator.pos.buffer_pos, *error_handler, iterator, - buffer_manager->context.client_data->debug_set_max_line_length, csv_file_scan, lines_read) { + buffer_manager->context.client_data->debug_set_max_line_length, csv_file_scan, lines_read, sniffing) { } StringValueScanner::StringValueScanner(const shared_ptr &buffer_manager, const shared_ptr &state_machine, const shared_ptr &error_handler) - : BaseScanner(buffer_manager, state_machine, error_handler, nullptr, {}), scanner_idx(0), + : BaseScanner(buffer_manager, state_machine, error_handler, false, nullptr, {}), scanner_idx(0), result(states, *state_machine, cur_buffer_handle, Allocator::DefaultAllocator(), STANDARD_VECTOR_SIZE, iterator.pos.buffer_pos, *error_handler, iterator, - buffer_manager->context.client_data->debug_set_max_line_length, csv_file_scan, lines_read) { + buffer_manager->context.client_data->debug_set_max_line_length, csv_file_scan, lines_read, sniffing) { } unique_ptr StringValueScanner::GetCSVScanner(ClientContext &context, CSVReaderOptions &options) { @@ -153142,6 +154431,8 @@ void StringValueScanner::Flush(DataChunk &insert_chunk) { auto &process_result = ParseChunk(); // First Get Parsed Chunk auto &parse_chunk = process_result.ToChunk(); + // We have to check if we got to error + error_handler->ErrorIfNeeded(); if (parse_chunk.size() == 0) { return; @@ -153173,6 +154464,7 @@ void StringValueScanner::Flush(DataChunk &insert_chunk) { result_vector.Reinterpret(parse_vector); } else { string error_message; + CastParameters parameters(false, &error_message); bool success; idx_t line_error = 0; bool line_error_set = true; @@ -153181,7 +154473,7 @@ void StringValueScanner::Flush(DataChunk &insert_chunk) { type.id() == LogicalTypeId::DATE) { // use the date format to cast the chunk success = CSVCast::TryCastDateVector(state_machine->options.dialect_options.date_format, parse_vector, - result_vector, parse_chunk.size(), error_message, line_error); + result_vector, parse_chunk.size(), parameters, line_error, true); } else if (!state_machine->options.dialect_options.date_format.at(LogicalTypeId::TIMESTAMP) .GetValue() .Empty() && @@ -153189,19 +154481,21 @@ void StringValueScanner::Flush(DataChunk &insert_chunk) { // use the date format to cast the chunk success = CSVCast::TryCastTimestampVector(state_machine->options.dialect_options.date_format, parse_vector, - result_vector, parse_chunk.size(), error_message); + result_vector, parse_chunk.size(), parameters, true); } else if (state_machine->options.decimal_separator != "." && (type.id() == LogicalTypeId::FLOAT || type.id() == LogicalTypeId::DOUBLE)) { success = CSVCast::TryCastFloatingVectorCommaSeparated(state_machine->options, parse_vector, result_vector, - parse_chunk.size(), error_message, type, line_error); + parse_chunk.size(), parameters, type, line_error); } else if (state_machine->options.decimal_separator != "." && type.id() == LogicalTypeId::DECIMAL) { - success = CSVCast::TryCastDecimalVectorCommaSeparated( - state_machine->options, parse_vector, result_vector, parse_chunk.size(), error_message, type); + success = + CSVCast::TryCastDecimalVectorCommaSeparated(state_machine->options, parse_vector, result_vector, + parse_chunk.size(), parameters, type, line_error); + } else { // target type is not varchar: perform a cast success = VectorOperations::TryCast(buffer_manager->context, parse_vector, result_vector, - parse_chunk.size(), &error_message); + parse_chunk.size(), &error_message, false, true); line_error_set = false; } if (success) { @@ -153222,14 +154516,19 @@ void StringValueScanner::Flush(DataChunk &insert_chunk) { } { vector row; - for (idx_t col = 0; col < parse_chunk.ColumnCount(); col++) { - row.push_back(parse_chunk.GetValue(col, line_error)); + + if (state_machine->options.ignore_errors) { + for (idx_t col = 0; col < parse_chunk.ColumnCount(); col++) { + row.push_back(parse_chunk.GetValue(col, line_error)); + } } - auto csv_error = CSVError::CastError(state_machine->options, csv_file_scan->names[col_idx], - error_message, col_idx, row); + LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), lines_read - parse_chunk.size() + line_error); - error_handler->Error(lines_per_batch, csv_error); + auto csv_error = + CSVError::CastError(state_machine->options, csv_file_scan->names[col_idx], error_message, col_idx, + row, lines_per_batch, result_vector.GetType().id()); + error_handler->Error(csv_error); } borked_lines.insert(line_error++); D_ASSERT(state_machine->options.ignore_errors); @@ -153242,11 +154541,13 @@ void StringValueScanner::Flush(DataChunk &insert_chunk) { for (idx_t col = 0; col < parse_chunk.ColumnCount(); col++) { row.push_back(parse_chunk.GetValue(col, line_error)); } - auto csv_error = CSVError::CastError(state_machine->options, csv_file_scan->names[col_idx], - error_message, col_idx, row); LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), lines_read - parse_chunk.size() + line_error); - error_handler->Error(lines_per_batch, csv_error); + auto csv_error = + CSVError::CastError(state_machine->options, csv_file_scan->names[col_idx], error_message, + col_idx, row, lines_per_batch, result_vector.GetType().id()); + + error_handler->Error(csv_error); } } } @@ -153300,17 +154601,19 @@ void StringValueScanner::ProcessExtraRow() { iterator.pos.buffer_pos++; return; } + lines_read++; iterator.pos.buffer_pos++; break; case CSVState::CARRIAGE_RETURN: - lines_read++; if (states.states[0] != CSVState::RECORD_SEPARATOR) { result.AddRow(result, iterator.pos.buffer_pos); iterator.pos.buffer_pos++; + lines_read++; return; } else { result.EmptyLine(result, iterator.pos.buffer_pos); iterator.pos.buffer_pos++; + lines_read++; return; } case CSVState::DELIMITER: @@ -153441,25 +154744,37 @@ void StringValueScanner::ProcessOverbufferValue() { } j++; } - string_t value; - if (result.quoted) { - value = string_t(overbuffer_string.c_str() + result.quoted_position, - overbuffer_string.size() - 1 - result.quoted_position); - if (result.escaped) { - const auto str_ptr = static_cast(overbuffer_string.c_str() + result.quoted_position); - value = - StringValueScanner::RemoveEscape(str_ptr, overbuffer_string.size() - 2, - state_machine->dialect_options.state_machine_options.escape.GetValue(), - result.parse_chunk.data[result.chunk_col_id]); + bool skip_value = false; + if (result.projecting_columns) { + if (!result.projected_columns[result.cur_col_id]) { + result.cur_col_id++; + skip_value = true; } - } else { - value = string_t(overbuffer_string.c_str(), overbuffer_string.size()); } - - if (states.EmptyLine() && state_machine->dialect_options.num_cols == 1) { - result.EmptyLine(result, iterator.pos.buffer_pos); - } else if (!states.IsNotSet()) { - result.AddValueToVector(value.GetData(), value.GetSize(), true); + if (!skip_value) { + string_t value; + if (result.quoted) { + value = string_t(overbuffer_string.c_str() + result.quoted_position, + UnsafeNumericCast(overbuffer_string.size() - 1 - result.quoted_position)); + if (result.escaped) { + const auto str_ptr = static_cast(overbuffer_string.c_str() + result.quoted_position); + value = StringValueScanner::RemoveEscape( + str_ptr, overbuffer_string.size() - 2, + state_machine->dialect_options.state_machine_options.escape.GetValue(), + result.parse_chunk.data[result.chunk_col_id]); + } + } else { + value = string_t(overbuffer_string.c_str(), UnsafeNumericCast(overbuffer_string.size())); + } + if (states.EmptyLine() && state_machine->dialect_options.num_cols == 1) { + result.EmptyLine(result, iterator.pos.buffer_pos); + } else if (!states.IsNotSet()) { + result.AddValueToVector(value.GetData(), value.GetSize(), true); + } + } else { + if (states.EmptyLine() && state_machine->dialect_options.num_cols == 1) { + result.EmptyLine(result, iterator.pos.buffer_pos); + } } if (states.NewRow() && !states.IsNotSet()) { @@ -153501,17 +154816,17 @@ bool StringValueScanner::MoveToNextBuffer() { result.chunk_col_id = 0; return false; } else if (states.NewValue()) { - lines_read++; // we add the value result.AddValue(result, previous_buffer_handle->actual_size); // And an extra empty value to represent what comes after the delimiter result.AddRow(result, previous_buffer_handle->actual_size); + lines_read++; } else if (states.IsQuotedCurrent()) { // Unterminated quote result.InvalidState(result); } else { - lines_read++; result.AddRow(result, previous_buffer_handle->actual_size); + lines_read++; } return false; } @@ -153558,12 +154873,15 @@ void StringValueScanner::SkipUntilNewLine() { if (state_machine->options.dialect_options.state_machine_options.new_line.GetValue() == NewLineIdentifier::CARRY_ON) { bool carriage_return = false; + bool not_carriage_return = false; for (; iterator.pos.buffer_pos < cur_buffer_handle->actual_size; iterator.pos.buffer_pos++) { if (buffer_handle_ptr[iterator.pos.buffer_pos] == '\r') { carriage_return = true; + } else if (buffer_handle_ptr[iterator.pos.buffer_pos] != '\n') { + not_carriage_return = true; } if (buffer_handle_ptr[iterator.pos.buffer_pos] == '\n') { - if (carriage_return) { + if (carriage_return || not_carriage_return) { iterator.pos.buffer_pos++; return; } @@ -153635,8 +154953,9 @@ void StringValueScanner::SetStart() { // When Null Padding, we assume we start from the correct new-line return; } - scan_finder = make_uniq(0, buffer_manager, state_machine, - make_shared(true), csv_file_scan, iterator, 1); + + scan_finder = make_uniq( + 0, buffer_manager, state_machine, make_shared(true), csv_file_scan, false, iterator, 1); auto &tuples = scan_finder->ParseChunk(); line_found = true; if (tuples.number_of_rows != 1) { @@ -153653,6 +154972,14 @@ void StringValueScanner::SetStart() { return; } } + if (iterator.pos.buffer_pos == cur_buffer_handle->actual_size) { + // If things go terribly wrong, we never loop indefinetly. + iterator.pos.buffer_idx = scan_finder->iterator.pos.buffer_idx; + iterator.pos.buffer_pos = scan_finder->iterator.pos.buffer_pos; + result.last_position = iterator.pos.buffer_pos; + iterator.done = scan_finder->iterator.done; + return; + } } } while (!line_found); iterator.pos.buffer_idx = scan_finder->result.pre_previous_line_start.buffer_idx; @@ -153810,10 +155137,12 @@ SnifferResult CSVSniffer::SniffCSV(bool force_match) { // 5. Type Replacement ReplaceTypes(); if (!best_candidate->error_handler->errors.empty() && !options.ignore_errors) { - for (auto &error : best_candidate->error_handler->errors) { - if (error.second.type == CSVErrorType::MAXIMUM_LINE_SIZE) { - // If it's a maximul line size error, we can do it now. - error_handler->Error(error.second); + for (auto &error_vector : best_candidate->error_handler->errors) { + for (auto &error : error_vector.second) { + if (error.type == CSVErrorType::MAXIMUM_LINE_SIZE) { + // If it's a maximum line size error, we can do it now. + error_handler->Error(error); + } } } auto error = CSVError::SniffingError(options.file_path); @@ -153850,6 +155179,8 @@ SnifferResult CSVSniffer::SniffCSV(bool force_match) { if (set_types[i] != detected_types[i] && !(set_types[i].IsNumeric() && detected_types[i].IsNumeric())) { type_error += "Column at position: " + to_string(i) + " Set type: " + set_types[i].ToString() + " Sniffed type: " + detected_types[i].ToString() + "\n"; + detected_types[i] = set_types[i]; + manually_set[i] = true; match = false; } } @@ -153860,13 +155191,14 @@ SnifferResult CSVSniffer::SniffCSV(bool force_match) { if (!error.empty() && force_match) { throw InvalidInputException(error); } - + options.was_type_manually_set = manually_set; // We do not need to run type refinement, since the types have been given by the user return SnifferResult({}, {}); } if (!error.empty() && force_match) { throw InvalidInputException(error); } + options.was_type_manually_set = manually_set; return SnifferResult(detected_types, names); } @@ -153962,6 +155294,10 @@ void CSVSniffer::AnalyzeDialectCandidate(unique_ptr scanner, idx_t &best_consistent_rows, idx_t &prev_padding_count) { // The sniffed_column_counts variable keeps track of the number of columns found for each row auto &sniffed_column_counts = scanner->ParseChunk(); + if (sniffed_column_counts.error) { + // This candidate has an error (i.e., over maximum line size or never unquoting quoted values) + return; + } idx_t start_row = options.dialect_options.skip_rows.GetValue(); idx_t consistent_rows = 0; idx_t num_cols = sniffed_column_counts.result_position == 0 ? 1 : sniffed_column_counts[start_row]; @@ -154103,15 +155439,14 @@ void CSVSniffer::RefineCandidates() { // Only one candidate nothing to refine or all candidates already checked return; } + vector> successful_candidates; for (auto &cur_candidate : candidates) { for (idx_t i = 1; i <= options.sample_size_chunks; i++) { bool finished_file = cur_candidate->FinishedFile(); if (finished_file || i == options.sample_size_chunks) { - // we finished the file or our chunk sample successfully: stop - auto successful_candidate = std::move(cur_candidate); - candidates.clear(); - candidates.emplace_back(std::move(successful_candidate)); - return; + // we finished the file or our chunk sample successfully + successful_candidates.push_back(std::move(cur_candidate)); + break; } if (!RefineCandidateNextChunk(*cur_candidate) || cur_candidate->GetResult().error) { // This candidate failed, move to the next one @@ -154119,7 +155454,25 @@ void CSVSniffer::RefineCandidates() { } } } + // If we have multiple candidates with quotes set, we will give the preference to ones + // that have actually quoted values, otherwise we will choose quotes = \0 candidates.clear(); + if (!successful_candidates.empty()) { + unique_ptr cc_best_candidate; + for (idx_t i = 0; i < successful_candidates.size(); i++) { + cc_best_candidate = std::move(successful_candidates[i]); + if (cc_best_candidate->state_machine->state_machine_options.quote != '\0' && + cc_best_candidate->ever_quoted) { + candidates.clear(); + candidates.push_back(std::move(cc_best_candidate)); + return; + } + if (cc_best_candidate->state_machine->state_machine_options.quote == '\0') { + candidates.push_back(std::move(cc_best_candidate)); + } + } + return; + } return; } @@ -154288,9 +155641,51 @@ static string NormalizeColumnName(const string &col_name) { } return col_name_cleaned; } + +// If our columns were set by the user, we verify if their names match with the first row +bool CSVSniffer::DetectHeaderWithSetColumn() { + bool has_header = true; + bool all_varchar = true; + bool first_row_consistent = true; + // User set the names, we must check if they match the first row + // We do a +1 to check for situations where the csv file has an extra all null column + if (set_columns.Size() != best_header_row.size() && set_columns.Size() + 1 != best_header_row.size()) { + return false; + } else { + // Let's do a match-aroo + for (idx_t i = 0; i < set_columns.Size(); i++) { + if (best_header_row[i].IsNull()) { + return false; + } + if (best_header_row[i] != (*set_columns.names)[i]) { + has_header = false; + break; + } + } + } + if (!has_header) { + // We verify if the types are consistent + for (idx_t col = 0; col < set_columns.Size(); col++) { + auto dummy_val = best_header_row[col]; + // try cast to sql_type of column + const auto &sql_type = (*set_columns.types)[col]; + if (sql_type != LogicalType::VARCHAR) { + all_varchar = false; + if (!TryCastValue(options.dialect_options, options.decimal_separator, dummy_val, sql_type)) { + first_row_consistent = false; + } + } + } + if (all_varchar) { + // Can't be the header + return false; + } + return !first_row_consistent; + } + return has_header; +} void CSVSniffer::DetectHeader() { auto &sniffer_state_machine = best_candidate->GetStateMachine(); - if (best_header_row.empty()) { sniffer_state_machine.dialect_options.header = false; for (idx_t col = 0; col < sniffer_state_machine.dialect_options.num_cols; col++) { @@ -154314,25 +155709,36 @@ void CSVSniffer::DetectHeader() { error_handler->Error(error); } bool all_varchar = true; - for (idx_t col = 0; col < best_header_row.size(); col++) { - auto dummy_val = best_header_row[col]; - if (!dummy_val.IsNull()) { - first_row_nulls = false; - } + bool has_header; - // try cast to sql_type of column - const auto &sql_type = best_sql_types_candidates_per_column_idx[col].back(); - if (sql_type != LogicalType::VARCHAR) { - all_varchar = false; - if (!TryCastValue(sniffer_state_machine, dummy_val, sql_type)) { - first_row_consistent = false; + if (set_columns.IsSet()) { + has_header = DetectHeaderWithSetColumn(); + } else { + for (idx_t col = 0; col < best_header_row.size(); col++) { + auto dummy_val = best_header_row[col]; + if (!dummy_val.IsNull()) { + first_row_nulls = false; + } + // try cast to sql_type of column + const auto &sql_type = best_sql_types_candidates_per_column_idx[col].back(); + if (sql_type != LogicalType::VARCHAR) { + all_varchar = false; + if (!TryCastValue(sniffer_state_machine.dialect_options, + sniffer_state_machine.options.decimal_separator, dummy_val, sql_type)) { + first_row_consistent = false; + } } } + // Our header is only false if types are not all varchar, and rows are consistent + if (all_varchar || first_row_nulls) { + has_header = true; + } else { + has_header = !first_row_consistent; + } } - bool has_header; - if (!sniffer_state_machine.options.dialect_options.header.IsSetByUser()) { - has_header = (!first_row_consistent || first_row_nulls) && !all_varchar; - } else { + + if (sniffer_state_machine.options.dialect_options.header.IsSetByUser()) { + // Header is defined by user, use that. has_header = sniffer_state_machine.options.dialect_options.header.GetValue(); } // update parser info, and read, generate & set col_names based on previous findings @@ -154404,7 +155810,8 @@ struct TryCastFloatingOperator { static bool Operation(string_t input) { T result; string error_message; - return OP::Operation(input, result, &error_message); + CastParameters parameters(false, &error_message); + return OP::Operation(input, result, parameters); } }; @@ -154478,27 +155885,28 @@ string GenerateDateFormat(const string &separator, const char *format_template) return result; } -bool CSVSniffer::TryCastValue(CSVStateMachine &candidate, const Value &value, const LogicalType &sql_type) { +bool CSVSniffer::TryCastValue(const DialectOptions &dialect_options, const string &decimal_separator, + const Value &value, const LogicalType &sql_type) { if (value.IsNull()) { return true; } - if (!candidate.dialect_options.date_format.find(LogicalTypeId::DATE)->second.GetValue().Empty() && + if (!dialect_options.date_format.find(LogicalTypeId::DATE)->second.GetValue().Empty() && sql_type.id() == LogicalTypeId::DATE) { date_t result; string error_message; - return candidate.dialect_options.date_format.find(LogicalTypeId::DATE) + return dialect_options.date_format.find(LogicalTypeId::DATE) ->second.GetValue() .TryParseDate(string_t(StringValue::Get(value)), result, error_message); } - if (!candidate.dialect_options.date_format.find(LogicalTypeId::TIMESTAMP)->second.GetValue().Empty() && + if (!dialect_options.date_format.find(LogicalTypeId::TIMESTAMP)->second.GetValue().Empty() && sql_type.id() == LogicalTypeId::TIMESTAMP) { timestamp_t result; string error_message; - return candidate.dialect_options.date_format.find(LogicalTypeId::TIMESTAMP) + return dialect_options.date_format.find(LogicalTypeId::TIMESTAMP) ->second.GetValue() .TryParseTimestamp(string_t(StringValue::Get(value)), result, error_message); } - if (candidate.options.decimal_separator != "." && (sql_type.id() == LogicalTypeId::DOUBLE)) { + if (decimal_separator != "." && (sql_type.id() == LogicalTypeId::DOUBLE)) { return TryCastFloatingOperator::Operation(StringValue::Get(value)); } Value new_value; @@ -154518,6 +155926,11 @@ void CSVSniffer::InitializeDateAndTimeStampDetection(CSVStateMachine &candidate, auto &format_candidate = format_candidates[sql_type.id()]; if (!format_candidate.initialized) { format_candidate.initialized = true; + // if user set a format, we add that as well + auto user_format = options.dialect_options.date_format.find(sql_type.id()); + if (user_format->second.IsSetByUser()) { + format_candidate.format.emplace_back(user_format->second.GetValue().format_specifier); + } // order by preference auto entry = format_template_candidates.find(sql_type.id()); if (entry != format_template_candidates.end()) { @@ -154579,6 +155992,7 @@ void CSVSniffer::DetectDateAndTimeStampFormats(CSVStateMachine &candidate, const void CSVSniffer::DetectTypes() { idx_t min_varchar_cols = max_columns_found + 1; + idx_t min_errors = NumericLimits::Maximum(); vector return_types; // check which info candidate leads to minimum amount of non-varchar columns... for (auto &candidate_cc : candidates) { @@ -154633,7 +156047,8 @@ void CSVSniffer::DetectTypes() { // Nothing to convert it to continue; } - if (TryCastValue(sniffing_state_machine, dummy_val, sql_type)) { + if (TryCastValue(sniffing_state_machine.dialect_options, + sniffing_state_machine.options.decimal_separator, dummy_val, sql_type)) { break; } else { if (row_idx != start_idx_detection && cur_top_candidate == LogicalType::BOOLEAN) { @@ -154663,7 +156078,9 @@ 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 (varchar_cols < min_varchar_cols && info_sql_types_candidates.size() > (max_columns_found * 0.7)) { + if (varchar_cols < min_varchar_cols && info_sql_types_candidates.size() > (max_columns_found * 0.7) && + (!options.ignore_errors || candidate->error_handler->errors.size() < min_errors)) { + min_errors = candidate->error_handler->errors.size(); best_header_row.clear(); // we have a new best_options candidate best_candidate = std::move(candidate); @@ -154681,7 +156098,7 @@ void CSVSniffer::DetectTypes() { } if (!best_candidate) { auto error = CSVError::SniffingError(options.file_path); - error_handler->Error(error); + error_handler->Error(error, true); } // Assert that it's all good at this point. D_ASSERT(best_candidate && !best_format_candidates.empty()); @@ -154701,16 +156118,18 @@ bool CSVSniffer::TryCastVector(Vector &parse_chunk_col, idx_t size, const Logica sql_type == LogicalTypeId::DATE) { // use the date format to cast the chunk string error_message; + CastParameters parameters(false, &error_message); idx_t line_error; return CSVCast::TryCastDateVector(sniffing_state_machine.dialect_options.date_format, parse_chunk_col, - dummy_result, size, error_message, line_error); + dummy_result, size, parameters, line_error); } if (!sniffing_state_machine.dialect_options.date_format[LogicalTypeId::TIMESTAMP].GetValue().Empty() && sql_type == LogicalTypeId::TIMESTAMP) { // use the timestamp format to cast the chunk string error_message; + CastParameters parameters(false, &error_message); return CSVCast::TryCastTimestampVector(sniffing_state_machine.dialect_options.date_format, parse_chunk_col, - dummy_result, size, error_message); + dummy_result, size, parameters); } // target type is not varchar: perform a cast string error_message; @@ -154783,6 +156202,7 @@ void CSVSniffer::RefineTypes() { namespace duckdb { void CSVSniffer::ReplaceTypes() { auto &sniffing_state_machine = best_candidate->GetStateMachine(); + manually_set = vector(detected_types.size(), false); if (sniffing_state_machine.options.sql_type_list.empty()) { return; } @@ -154797,14 +156217,14 @@ void CSVSniffer::ReplaceTypes() { best_sql_types_candidates_per_column_idx[i] = { sniffing_state_machine.options.sql_type_list[it->second]}; detected_types[i] = sniffing_state_machine.options.sql_type_list[it->second]; + manually_set[i] = true; found++; } } if (!sniffing_state_machine.options.file_options.union_by_name && found < sniffing_state_machine.options.sql_types_per_column.size()) { auto error_msg = CSVError::ColumnTypesError(options.sql_types_per_column, names); - auto error_line = LinesPerBoundary(0, 0); - error_handler->Error(error_line, error_msg); + error_handler->Error(error_msg); } return; } @@ -154815,6 +156235,7 @@ void CSVSniffer::ReplaceTypes() { } for (idx_t i = 0; i < sniffing_state_machine.options.sql_type_list.size(); i++) { detected_types[i] = sniffing_state_machine.options.sql_type_list[i]; + manually_set[i] = true; } } } // namespace duckdb @@ -154845,8 +156266,6 @@ CSVStateMachine::CSVStateMachine(const StateMachine &transition_array_p, const C namespace duckdb { -const string CSVStateMachineCache::STATE_KEY = "CSV_STATE_MACHINE_CACHE"; - void InitializeTransitionArray(StateMachine &transition_array, const CSVState cur_state, const CSVState state) { for (uint32_t i = 0; i < StateMachine::NUM_TRANSITIONS; i++) { transition_array[i][static_cast(cur_state)] = state; @@ -155007,6 +156426,33 @@ void CSVStateMachineCache::Insert(const CSVStateMachineOptions &state_machine_op transition_array.skip_quoted[escape] = false; transition_array.skip_quoted[static_cast('\n')] = false; transition_array.skip_quoted[static_cast('\r')] = false; + + transition_array.delimiter = delimiter; + transition_array.new_line = static_cast('\n'); + transition_array.carriage_return = static_cast('\r'); + transition_array.quote = quote; + transition_array.escape = escape; + + // Shift and OR to replicate across all bytes + transition_array.delimiter |= transition_array.delimiter << 8; + transition_array.delimiter |= transition_array.delimiter << 16; + transition_array.delimiter |= transition_array.delimiter << 32; + + transition_array.new_line |= transition_array.new_line << 8; + transition_array.new_line |= transition_array.new_line << 16; + transition_array.new_line |= transition_array.new_line << 32; + + transition_array.carriage_return |= transition_array.carriage_return << 8; + transition_array.carriage_return |= transition_array.carriage_return << 16; + transition_array.carriage_return |= transition_array.carriage_return << 32; + + transition_array.quote |= transition_array.quote << 8; + transition_array.quote |= transition_array.quote << 16; + transition_array.quote |= transition_array.quote << 32; + + transition_array.escape |= transition_array.escape << 8; + transition_array.escape |= transition_array.escape << 16; + transition_array.escape |= transition_array.escape << 32; } CSVStateMachineCache::CSVStateMachineCache() { @@ -155037,7 +156483,7 @@ const StateMachine &CSVStateMachineCache::Get(const CSVStateMachineOptions &stat CSVStateMachineCache &CSVStateMachineCache::Get(ClientContext &context) { auto &cache = ObjectCache::GetObjectCache(context); - return *cache.GetOrCreate(CSVStateMachineCache::STATE_KEY); + return *cache.GetOrCreate(CSVStateMachineCache::ObjectType()); } } // namespace duckdb @@ -155128,6 +156574,10 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons names = bind_data.column_info[file_idx].names; types = bind_data.column_info[file_idx].types; options.dialect_options.num_cols = names.size(); + if (options.auto_detect) { + CSVSniffer sniffer(options, buffer_manager, state_machine_cache); + sniffer.SniffCSV(); + } state_machine = make_shared( state_machine_cache.Get(options.dialect_options.state_machine_options), options); @@ -155265,7 +156715,7 @@ void CSVFileScan::InitializeProjection() { //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/csv_scanner/table_function/global_csv_state.hpp +// duckdb/execution/operator/csv_scanner/global_csv_state.hpp // // //===----------------------------------------------------------------------===// @@ -155315,7 +156765,7 @@ struct CSVGlobalState : public GlobalTableFunctionState { vector> file_scans; //! Mutex to lock when getting next batch of bytes (Parallel Only) - mutex main_mutex; + mutable mutex main_mutex; //! Basically max number of threads in DuckDB idx_t system_threads; @@ -155423,7 +156873,7 @@ CSVGlobalState::CSVGlobalState(ClientContext &context_p, const shared_ptr parallel_lock(main_mutex); idx_t total_files = bind_data.files.size(); // get the progress WITHIN the current file double progress; @@ -155454,7 +156904,7 @@ unique_ptr CSVGlobalState::Next() { } auto csv_scanner = make_uniq(scanner_idx++, current_file->buffer_manager, current_file->state_machine, - current_file->error_handler, current_file, current_boundary); + current_file->error_handler, current_file, false, current_boundary); return csv_scanner; } lock_guard parallel_lock(main_mutex); @@ -155469,7 +156919,7 @@ unique_ptr CSVGlobalState::Next() { auto ¤t_file = *file_scans.back(); auto csv_scanner = make_uniq(scanner_idx++, current_file.buffer_manager, current_file.state_machine, - current_file.error_handler, file_scans.back(), current_boundary); + current_file.error_handler, file_scans.back(), false, current_boundary); csv_scanner->buffer_tracker = current_buffer_in_use; @@ -155534,51 +156984,52 @@ void CSVGlobalState::FillRejectsTable() { for (auto &file : file_scans) { auto file_name = file->file_path; auto &errors = file->error_handler->errors; - for (auto &error_info : errors) { - if (error_info.second.type != CSVErrorType::CAST_ERROR) { - // For now we only will use it for casting errors - continue; - } - // short circuit if we already have too many rejects - if (limit == 0 || rejects->count < limit) { - if (limit != 0 && rejects->count >= limit) { - break; + for (auto &error_vector : errors) { + for (auto &error : error_vector.second) { + if (error.type != CSVErrorType::CAST_ERROR) { + // For now we only will use it for casting errors + continue; } - rejects->count++; - auto error = &error_info.second; - auto row_line = file->error_handler->GetLine(error_info.first); - auto col_idx = error->column_idx; - auto col_name = bind_data.return_names[col_idx]; - // Add the row to the rejects table - appender.BeginRow(); - appender.Append(string_t(file_name)); - appender.Append(row_line); - appender.Append(col_idx); - appender.Append(string_t("\"" + col_name + "\"")); - appender.Append(error->row[col_idx]); - - if (!options.rejects_recovery_columns.empty()) { - child_list_t recovery_key; - for (auto &key_idx : options.rejects_recovery_column_ids) { - // Figure out if the recovery key is valid. - // If not, error out for real. - auto &value = error->row[key_idx]; - if (value.IsNull()) { - throw InvalidInputException("%s at line %llu in column %s. Parser options:\n%s ", - "Could not parse recovery column", row_line, col_name, - options.ToString()); + // 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; + auto col_name = bind_data.return_names[col_idx]; + // Add the row to the rejects table + appender.BeginRow(); + appender.Append(string_t(file_name)); + appender.Append(row_line); + appender.Append(col_idx); + appender.Append(string_t("\"" + col_name + "\"")); + appender.Append(error.row[col_idx]); + + if (!options.rejects_recovery_columns.empty()) { + child_list_t recovery_key; + for (auto &key_idx : options.rejects_recovery_column_ids) { + // Figure out if the recovery key is valid. + // If not, error out for real. + auto &value = error.row[key_idx]; + if (value.IsNull()) { + throw InvalidInputException("%s at line %llu in column %s. Parser options:\n%s ", + "Could not parse recovery column", row_line, col_name, + options.ToString()); + } + recovery_key.emplace_back(bind_data.return_names[key_idx], value); } - recovery_key.emplace_back(bind_data.return_names[key_idx], value); + appender.Append(Value::STRUCT(recovery_key)); } - appender.Append(Value::STRUCT(recovery_key)); + auto row_error_msg = + StringUtil::Format("Could not convert string '%s' to '%s'", error.row[col_idx].ToString(), + file->types[col_idx].ToString()); + appender.Append(string_t(row_error_msg)); + appender.EndRow(); } - auto row_error_msg = - StringUtil::Format("Could not convert string '%s' to '%s'", error->row[col_idx].ToString(), - file->types[col_idx].ToString()); - appender.Append(string_t(row_error_msg)); - appender.EndRow(); + appender.Close(); } - appender.Close(); } } } @@ -155600,25 +157051,10 @@ LinesPerBoundary::LinesPerBoundary(idx_t boundary_idx_p, idx_t lines_in_batch_p) CSVErrorHandler::CSVErrorHandler(bool ignore_errors_p) : ignore_errors(ignore_errors_p) { } -void CSVErrorHandler::Error(CSVError &csv_error) { - LinesPerBoundary mock; - Error(mock, csv_error, true); -} -void CSVErrorHandler::Error(LinesPerBoundary &error_info, CSVError &csv_error, bool force_error) { - if (ignore_errors && !force_error) { - lock_guard parallel_lock(main_mutex); - // We store this error - errors.push_back({error_info, csv_error}); - return; - } - +void CSVErrorHandler::ThrowError(CSVError csv_error) { std::ostringstream error; if (PrintLineNumber(csv_error)) { - error << "CSV Error on Line: " << GetLine(error_info) << std::endl; - } - { - lock_guard parallel_lock(main_mutex); - got_borked = true; + error << "CSV Error on Line: " << GetLine(csv_error.error_info) << std::endl; } error << csv_error.error_message; switch (csv_error.type) { @@ -155633,6 +157069,33 @@ void CSVErrorHandler::Error(LinesPerBoundary &error_info, CSVError &csv_error, b } } +void CSVErrorHandler::Error(CSVError csv_error, bool force_error) { + if ((ignore_errors && !force_error) || (PrintLineNumber(csv_error) && !CanGetLine(csv_error.GetBoundaryIndex()))) { + lock_guard parallel_lock(main_mutex); + // 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)); + return; + } + // Otherwise we can throw directly + ThrowError(csv_error); +} + +void CSVErrorHandler::ErrorIfNeeded() { + CSVError first_error; + { + lock_guard parallel_lock(main_mutex); + if (ignore_errors || errors.empty()) { + // Nothing to error + return; + } + first_error = errors.begin()->second[0]; + } + + if (CanGetLine(first_error.error_info.boundary_idx)) { + ThrowError(first_error); + } +} + void CSVErrorHandler::Insert(idx_t boundary_idx, idx_t rows) { lock_guard parallel_lock(main_mutex); if (lines_per_batch_map.find(boundary_idx) == lines_per_batch_map.end()) { @@ -155647,12 +157110,14 @@ void CSVErrorHandler::NewMaxLineSize(idx_t scan_line_size) { max_line_length = std::max(scan_line_size, max_line_length); } -CSVError::CSVError(string error_message_p, CSVErrorType type_p) - : error_message(std::move(error_message_p)), type(type_p) { +CSVError::CSVError(string error_message_p, CSVErrorType type_p, LinesPerBoundary error_info_p) + : error_message(std::move(error_message_p)), type(type_p), error_info(error_info_p) { } -CSVError::CSVError(string error_message_p, CSVErrorType type_p, idx_t column_idx_p, vector row_p) - : error_message(std::move(error_message_p)), type(type_p), column_idx(column_idx_p), row(std::move(row_p)) { +CSVError::CSVError(string error_message_p, CSVErrorType type_p, idx_t column_idx_p, vector row_p, + LinesPerBoundary error_info_p) + : error_message(std::move(error_message_p)), type(type_p), column_idx(column_idx_p), row(std::move(row_p)), + error_info(error_info_p) { } CSVError CSVError::ColumnTypesError(case_insensitive_map_t sql_types_per_column, const vector &names) { @@ -155664,7 +157129,7 @@ CSVError CSVError::ColumnTypesError(case_insensitive_map_t sql_types_per_ } } if (sql_types_per_column.empty()) { - return CSVError("", CSVErrorType::COLUMN_NAME_TYPE_MISMATCH); + return CSVError("", CSVErrorType::COLUMN_NAME_TYPE_MISMATCH, {}); } string exception = "COLUMN_TYPES error: Columns with names: "; for (auto &col : sql_types_per_column) { @@ -155672,28 +157137,43 @@ CSVError CSVError::ColumnTypesError(case_insensitive_map_t sql_types_per_ } exception.pop_back(); exception += " do not exist in the CSV File"; - return CSVError(exception, CSVErrorType::COLUMN_NAME_TYPE_MISMATCH); + return CSVError(exception, CSVErrorType::COLUMN_NAME_TYPE_MISMATCH, {}); } CSVError CSVError::CastError(const CSVReaderOptions &options, string &column_name, string &cast_error, idx_t column_idx, - vector &row) { + vector &row, LinesPerBoundary error_info, LogicalTypeId type) { std::ostringstream error; // Which column error << "Error when converting column \"" << column_name << "\"." << std::endl; // What was the cast error error << cast_error << std::endl; - error << std::endl; - // What were the options + + error << "Column " << column_name << " is being converted as type " << LogicalTypeIdToString(type) << std::endl; + if (!options.WasTypeManuallySet(column_idx)) { + error << "This type was auto-detected from the CSV file." << std::endl; + error << "Possible solutions:" << std::endl; + error << "* Override the type for this column manually by setting the type explicitly, e.g. types={'" + << column_name << "': 'VARCHAR'}" << std::endl; + error << "* Set the sample size to a larger value to enable the auto-detection to scan more values, e.g. " + "sample_size=-1" + << std::endl; + error << "* Use a COPY statement to automatically derive types from an existing table." << std::endl; + } else { + error << "This type was either manually set or derived from an existing table. Select a different type to " + "correctly parse this column." + << std::endl; + } error << options.ToString(); - return CSVError(error.str(), CSVErrorType::CAST_ERROR, column_idx, row); + + return CSVError(error.str(), CSVErrorType::CAST_ERROR, column_idx, row, error_info); } -CSVError CSVError::LineSizeError(const CSVReaderOptions &options, idx_t actual_size) { +CSVError CSVError::LineSizeError(const CSVReaderOptions &options, idx_t actual_size, LinesPerBoundary error_info) { std::ostringstream error; error << "Maximum line size of " << options.maximum_line_size << " bytes exceeded. "; error << "Actual Size:" << actual_size << " bytes." << std::endl; error << options.ToString(); - return CSVError(error.str(), CSVErrorType::MAXIMUM_LINE_SIZE); + return CSVError(error.str(), CSVErrorType::MAXIMUM_LINE_SIZE, error_info); } CSVError CSVError::SniffingError(string &file_path) { @@ -155701,72 +157181,91 @@ CSVError CSVError::SniffingError(string &file_path) { // Which column error << "Error when sniffing file \"" << file_path << "\"." << std::endl; error << "CSV options could not be auto-detected. Consider setting parser options manually." << std::endl; - return CSVError(error.str(), CSVErrorType::SNIFFING); + return CSVError(error.str(), CSVErrorType::SNIFFING, {}); } -CSVError CSVError::NullPaddingFail(const CSVReaderOptions &options) { +CSVError CSVError::NullPaddingFail(const CSVReaderOptions &options, LinesPerBoundary error_info) { std::ostringstream error; error << " The parallel scanner does not support null_padding in conjunction with quoted new lines. Please " "disable the parallel csv reader with parallel=false" << std::endl; // What were the options error << options.ToString(); - return CSVError(error.str(), CSVErrorType::NULLPADDED_QUOTED_NEW_VALUE); + return CSVError(error.str(), CSVErrorType::NULLPADDED_QUOTED_NEW_VALUE, error_info); } CSVError CSVError::UnterminatedQuotesError(const CSVReaderOptions &options, string_t *vector_ptr, - idx_t vector_line_start, idx_t current_column) { + idx_t vector_line_start, idx_t current_column, LinesPerBoundary error_info) { std::ostringstream error; error << "Value with unterminated quote found." << std::endl; error << std::endl; // What were the options error << options.ToString(); - return CSVError(error.str(), CSVErrorType::UNTERMINATED_QUOTES); + return CSVError(error.str(), CSVErrorType::UNTERMINATED_QUOTES, error_info); } CSVError CSVError::IncorrectColumnAmountError(const CSVReaderOptions &options, string_t *vector_ptr, - idx_t vector_line_start, idx_t actual_columns) { + idx_t vector_line_start, idx_t actual_columns, + LinesPerBoundary error_info) { std::ostringstream error; // How many columns were expected and how many were found error << "Expected Number of Columns: " << options.dialect_options.num_cols << " Found: " << actual_columns << std::endl; + error << std::endl << "Possible fixes:" << std::endl; + if (!options.null_padding) { + error << "* Enable null padding (null_padding=true) to replace missing values with NULL" << std::endl; + } + if (!options.ignore_errors) { + error << "* Enable ignore errors (ignore_errors=true) to skip this row" << std::endl; + } + error << std::endl; // What were the options error << options.ToString(); - return CSVError(error.str(), CSVErrorType::INCORRECT_COLUMN_AMOUNT); + return CSVError(error.str(), CSVErrorType::INCORRECT_COLUMN_AMOUNT, error_info); +} + +CSVError CSVError::InvalidUTF8(const CSVReaderOptions &options, LinesPerBoundary error_info) { + std::ostringstream error; + // How many columns were expected and how many were found + error << "Invalid unicode (byte sequence mismatch) detected." << std::endl; + // What were the options + error << options.ToString(); + return CSVError(error.str(), CSVErrorType::INVALID_UNICODE, error_info); } bool CSVErrorHandler::PrintLineNumber(CSVError &error) { + if (!print_line) { + return false; + } switch (error.type) { case CSVErrorType::CAST_ERROR: case CSVErrorType::UNTERMINATED_QUOTES: case CSVErrorType::INCORRECT_COLUMN_AMOUNT: case CSVErrorType::MAXIMUM_LINE_SIZE: case CSVErrorType::NULLPADDED_QUOTED_NEW_VALUE: + case CSVErrorType::INVALID_UNICODE: return true; default: return false; } } -idx_t CSVErrorHandler::GetLine(LinesPerBoundary &error_info) { - idx_t current_line = 1 + error_info.lines_in_batch; // We start from one, since the lines are 1-indexed - for (idx_t boundary_idx = 0; boundary_idx < error_info.boundary_idx; boundary_idx++) { - bool batch_done = false; - while (!batch_done) { - if (boundary_idx == 0) { - // if it's the first boundary, we just return - break; - } - lock_guard parallel_lock(main_mutex); - if (lines_per_batch_map.find(boundary_idx) != lines_per_batch_map.end()) { - batch_done = true; - current_line += lines_per_batch_map[boundary_idx].lines_in_batch; - } - if (got_borked) { - return current_line; - } +bool CSVErrorHandler::CanGetLine(idx_t boundary_index) { + for (idx_t i = 0; i < boundary_index; i++) { + if (lines_per_batch_map.find(i) == lines_per_batch_map.end()) { + return false; } } + return true; +} + +idx_t CSVErrorHandler::GetLine(const LinesPerBoundary &error_info) { + lock_guard parallel_lock(main_mutex); + // We start from one, since the lines are 1-indexed + idx_t current_line = 1 + error_info.lines_in_batch; + for (idx_t boundary_idx = 0; boundary_idx < error_info.boundary_idx; boundary_idx++) { + current_line += lines_per_batch_map[boundary_idx].lines_in_batch; + } return current_line; } @@ -156070,6 +157569,13 @@ template string FormatOptionLine(const string &name, const CSVOption option) { return name + " = " + option.FormatValue() + " " + option.FormatSet() + "\n "; } +bool CSVReaderOptions::WasTypeManuallySet(idx_t i) const { + if (i >= was_type_manually_set.size()) { + return false; + } + return was_type_manually_set[i]; +} + string CSVReaderOptions::ToString() const { auto &delimiter = dialect_options.state_machine_options.delimiter; auto "e = dialect_options.state_machine_options.quote; @@ -157084,6 +158590,7 @@ SourceResultType PhysicalExplainAnalyze::GetData(ExecutionContext &context, Data + namespace duckdb { //! PhyisicalLimit represents the LIMIT operator @@ -157091,14 +158598,14 @@ class PhysicalLimit : public PhysicalOperator { public: static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::LIMIT; + static constexpr const idx_t MAX_LIMIT_VALUE = 1ULL << 62ULL; + public: - PhysicalLimit(vector types, idx_t limit, idx_t offset, unique_ptr limit_expression, - unique_ptr offset_expression, idx_t estimated_cardinality); + PhysicalLimit(vector types, BoundLimitNode limit_val, BoundLimitNode offset_val, + idx_t estimated_cardinality); - idx_t limit_value; - idx_t offset_value; - unique_ptr limit_expression; - unique_ptr offset_expression; + BoundLimitNode limit_val; + BoundLimitNode offset_val; public: bool SinkOrderDependent() const override { @@ -157134,11 +158641,13 @@ class PhysicalLimit : public PhysicalOperator { } public: - static bool ComputeOffset(ExecutionContext &context, DataChunk &input, idx_t &limit, idx_t &offset, - idx_t current_offset, idx_t &max_element, Expression *limit_expression, - Expression *offset_expression); + static void SetInitialLimits(const BoundLimitNode &limit_val, const BoundLimitNode &offset_val, optional_idx &limit, + optional_idx &offset); + static bool ComputeOffset(ExecutionContext &context, DataChunk &input, optional_idx &limit, optional_idx &offset, + idx_t current_offset, idx_t &max_element, const BoundLimitNode &limit_val, + const BoundLimitNode &offset_val); static bool HandleOffset(DataChunk &input, idx_t ¤t_offset, idx_t offset, idx_t limit); - static Value GetDelimiter(ExecutionContext &context, DataChunk &input, Expression *expr); + static Value GetDelimiter(ExecutionContext &context, DataChunk &input, const Expression &expr); }; } // namespace duckdb @@ -157160,6 +158669,7 @@ class PhysicalLimit : public PhysicalOperator { + namespace duckdb { class PhysicalStreamingLimit : public PhysicalOperator { @@ -157167,14 +158677,11 @@ class PhysicalStreamingLimit : public PhysicalOperator { static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::STREAMING_LIMIT; public: - PhysicalStreamingLimit(vector types, idx_t limit, idx_t offset, - unique_ptr limit_expression, unique_ptr offset_expression, + PhysicalStreamingLimit(vector types, BoundLimitNode limit_val_p, BoundLimitNode offset_val_p, idx_t estimated_cardinality, bool parallel); - idx_t limit_value; - idx_t offset_value; - unique_ptr limit_expression; - unique_ptr offset_expression; + BoundLimitNode limit_val; + BoundLimitNode offset_val; bool parallel; public: @@ -157194,12 +158701,10 @@ class PhysicalStreamingLimit : public PhysicalOperator { namespace duckdb { -PhysicalLimit::PhysicalLimit(vector types, idx_t limit, idx_t offset, - unique_ptr limit_expression, unique_ptr offset_expression, +PhysicalLimit::PhysicalLimit(vector types, BoundLimitNode limit_val_p, BoundLimitNode offset_val_p, idx_t estimated_cardinality) - : PhysicalOperator(PhysicalOperatorType::LIMIT, std::move(types), estimated_cardinality), limit_value(limit), - offset_value(offset), limit_expression(std::move(limit_expression)), - offset_expression(std::move(offset_expression)) { + : PhysicalOperator(PhysicalOperatorType::LIMIT, std::move(types), estimated_cardinality), + limit_val(std::move(limit_val_p)), offset_val(std::move(offset_val_p)) { } //===--------------------------------------------------------------------===// @@ -157222,13 +158727,12 @@ class LimitLocalState : public LocalSinkState { public: explicit LimitLocalState(ClientContext &context, const PhysicalLimit &op) : current_offset(0), data(context, op.types, true) { - this->limit = op.limit_expression ? DConstants::INVALID_INDEX : op.limit_value; - this->offset = op.offset_expression ? DConstants::INVALID_INDEX : op.offset_value; + PhysicalLimit::SetInitialLimits(op.limit_val, op.offset_val, limit, offset); } idx_t current_offset; - idx_t limit; - idx_t offset; + optional_idx limit; + optional_idx offset; BatchedDataCollection data; }; @@ -157240,38 +158744,56 @@ unique_ptr PhysicalLimit::GetLocalSinkState(ExecutionContext &co return make_uniq(context.client, *this); } -bool PhysicalLimit::ComputeOffset(ExecutionContext &context, DataChunk &input, idx_t &limit, idx_t &offset, - idx_t current_offset, idx_t &max_element, Expression *limit_expression, - Expression *offset_expression) { - if (limit != DConstants::INVALID_INDEX && offset != DConstants::INVALID_INDEX) { - max_element = limit + offset; - if ((limit == 0 || current_offset >= max_element) && !(limit_expression || offset_expression)) { - return false; - } +void PhysicalLimit::SetInitialLimits(const BoundLimitNode &limit_val, const BoundLimitNode &offset_val, + optional_idx &limit, optional_idx &offset) { + switch (limit_val.Type()) { + case LimitNodeType::CONSTANT_VALUE: + limit = limit_val.GetConstantValue(); + break; + case LimitNodeType::UNSET: + limit = MAX_LIMIT_VALUE; + break; + default: + break; + } + switch (offset_val.Type()) { + case LimitNodeType::CONSTANT_VALUE: + offset = offset_val.GetConstantValue(); + break; + case LimitNodeType::UNSET: + offset = 0; + break; + default: + break; } +} - // get the next chunk from the child - if (limit == DConstants::INVALID_INDEX) { - limit = 1ULL << 62ULL; - Value val = GetDelimiter(context, input, limit_expression); +bool PhysicalLimit::ComputeOffset(ExecutionContext &context, DataChunk &input, optional_idx &limit, + optional_idx &offset, idx_t current_offset, idx_t &max_element, + const BoundLimitNode &limit_val, const BoundLimitNode &offset_val) { + if (!limit.IsValid()) { + Value val = GetDelimiter(context, input, limit_val.GetValueExpression()); if (!val.IsNull()) { limit = val.GetValue(); + } else { + limit = MAX_LIMIT_VALUE; } - if (limit > 1ULL << 62ULL) { - throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", limit, 1ULL << 62ULL); + if (limit.GetIndex() > MAX_LIMIT_VALUE) { + throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", limit.GetIndex(), MAX_LIMIT_VALUE); } } - if (offset == DConstants::INVALID_INDEX) { - offset = 0; - Value val = GetDelimiter(context, input, offset_expression); + if (!offset.IsValid()) { + Value val = GetDelimiter(context, input, offset_val.GetValueExpression()); if (!val.IsNull()) { offset = val.GetValue(); + } else { + offset = 0; } - if (offset > 1ULL << 62ULL) { - throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset, 1ULL << 62ULL); + if (offset.GetIndex() > MAX_LIMIT_VALUE) { + throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset.GetIndex(), MAX_LIMIT_VALUE); } } - max_element = limit + offset; + max_element = limit.GetIndex() + offset.GetIndex(); if (limit == 0 || current_offset >= max_element) { return false; } @@ -157286,8 +158808,7 @@ SinkResultType PhysicalLimit::Sink(ExecutionContext &context, DataChunk &chunk, auto &offset = state.offset; idx_t max_element; - if (!ComputeOffset(context, chunk, limit, offset, state.current_offset, max_element, limit_expression.get(), - offset_expression.get())) { + if (!ComputeOffset(context, chunk, limit, offset, state.current_offset, max_element, limit_val, offset_val)) { return SinkResultType::FINISHED; } auto max_cardinality = max_element - state.current_offset; @@ -157307,8 +158828,12 @@ SinkCombineResultType PhysicalLimit::Combine(ExecutionContext &context, Operator auto &state = input.local_state.Cast(); lock_guard lock(gstate.glock); - gstate.limit = state.limit; - gstate.offset = state.offset; + if (state.limit.IsValid()) { + gstate.limit = state.limit.GetIndex(); + } + if (state.offset.IsValid()) { + gstate.offset = state.offset.GetIndex(); + } gstate.data.Merge(state.data); return SinkCombineResultType::FINISHED; @@ -157395,12 +158920,12 @@ bool PhysicalLimit::HandleOffset(DataChunk &input, idx_t ¤t_offset, idx_t return true; } -Value PhysicalLimit::GetDelimiter(ExecutionContext &context, DataChunk &input, Expression *expr) { +Value PhysicalLimit::GetDelimiter(ExecutionContext &context, DataChunk &input, const Expression &expr) { DataChunk limit_chunk; - vector types {expr->return_type}; + vector types {expr.return_type}; auto &allocator = Allocator::Get(context.client); limit_chunk.Initialize(allocator, types); - ExpressionExecutor limit_executor(context.client, expr); + ExpressionExecutor limit_executor(context.client, &expr); auto input_size = input.size(); input.SetCardinality(1); limit_executor.Execute(input, limit_chunk); @@ -157423,6 +158948,7 @@ Value PhysicalLimit::GetDelimiter(ExecutionContext &context, DataChunk &input, E + namespace duckdb { //! PhyisicalLimitPercent represents the LIMIT PERCENT operator @@ -157431,18 +158957,11 @@ class PhysicalLimitPercent : public PhysicalOperator { static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::LIMIT_PERCENT; public: - PhysicalLimitPercent(vector types, double limit_percent, idx_t offset, - unique_ptr limit_expression, unique_ptr offset_expression, - idx_t estimated_cardinality) - : PhysicalOperator(PhysicalOperatorType::LIMIT_PERCENT, std::move(types), estimated_cardinality), - limit_percent(limit_percent), offset_value(offset), limit_expression(std::move(limit_expression)), - offset_expression(std::move(offset_expression)) { - } + PhysicalLimitPercent(vector types, BoundLimitNode limit_val_p, BoundLimitNode offset_val_p, + idx_t estimated_cardinality); - double limit_percent; - idx_t offset_value; - unique_ptr limit_expression; - unique_ptr offset_expression; + BoundLimitNode limit_val; + BoundLimitNode offset_val; public: bool SinkOrderDependent() const override { @@ -157478,6 +158997,13 @@ class PhysicalLimitPercent : public PhysicalOperator { namespace duckdb { +PhysicalLimitPercent::PhysicalLimitPercent(vector types, BoundLimitNode limit_val_p, + BoundLimitNode offset_val_p, idx_t estimated_cardinality) + : PhysicalOperator(PhysicalOperatorType::LIMIT_PERCENT, std::move(types), estimated_cardinality), + limit_val(std::move(limit_val_p)), offset_val(std::move(offset_val_p)) { + D_ASSERT(limit_val.Type() == LimitNodeType::CONSTANT_PERCENTAGE || + limit_val.Type() == LimitNodeType::EXPRESSION_PERCENTAGE); +} //===--------------------------------------------------------------------===// // Sink //===--------------------------------------------------------------------===// @@ -157485,28 +159011,37 @@ class LimitPercentGlobalState : public GlobalSinkState { public: explicit LimitPercentGlobalState(ClientContext &context, const PhysicalLimitPercent &op) : current_offset(0), data(context, op.GetTypes()) { - if (!op.limit_expression) { - this->limit_percent = op.limit_percent; - is_limit_percent_delimited = true; - } else { - this->limit_percent = 100.0; + switch (op.limit_val.Type()) { + case LimitNodeType::CONSTANT_PERCENTAGE: + this->limit_percent = op.limit_val.GetConstantPercentage(); + this->is_limit_set = true; + break; + case LimitNodeType::EXPRESSION_PERCENTAGE: + this->is_limit_set = false; + break; + default: + throw InternalException("Unsupported type for limit value in PhysicalLimitPercent"); } - - if (!op.offset_expression) { - this->offset = op.offset_value; - is_offset_delimited = true; - } else { + switch (op.offset_val.Type()) { + case LimitNodeType::CONSTANT_VALUE: + this->offset = op.offset_val.GetConstantValue(); + break; + case LimitNodeType::UNSET: this->offset = 0; + break; + case LimitNodeType::EXPRESSION_VALUE: + break; + default: + throw InternalException("Unsupported type for offset value in PhysicalLimitPercent"); } } idx_t current_offset; double limit_percent; - idx_t offset; + optional_idx offset; ColumnDataCollection data; - bool is_limit_percent_delimited = false; - bool is_offset_delimited = false; + bool is_limit_set = false; }; unique_ptr PhysicalLimitPercent::GetGlobalSinkState(ClientContext &context) const { @@ -157520,28 +159055,31 @@ SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, DataChunk & auto &offset = state.offset; // get the next chunk from the child - if (!state.is_limit_percent_delimited) { - Value val = PhysicalLimit::GetDelimiter(context, chunk, limit_expression.get()); + if (!state.is_limit_set) { + Value val = PhysicalLimit::GetDelimiter(context, chunk, limit_val.GetPercentageExpression()); if (!val.IsNull()) { limit_percent = val.GetValue(); + } else { + limit_percent = 100.0; } if (limit_percent < 0.0) { throw BinderException("Percentage value(%f) can't be negative", limit_percent); } - state.is_limit_percent_delimited = true; + state.is_limit_set = true; } - if (!state.is_offset_delimited) { - Value val = PhysicalLimit::GetDelimiter(context, chunk, offset_expression.get()); + if (!state.offset.IsValid()) { + Value val = PhysicalLimit::GetDelimiter(context, chunk, offset_val.GetValueExpression()); if (!val.IsNull()) { offset = val.GetValue(); + } else { + offset = 0; } - if (offset > 1ULL << 62ULL) { - throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset, 1ULL << 62ULL); + if (offset.GetIndex() > 1ULL << 62ULL) { + throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset.GetIndex(), 1ULL << 62ULL); } - state.is_offset_delimited = true; } - if (!PhysicalLimit::HandleOffset(chunk, state.current_offset, offset, DConstants::INVALID_INDEX)) { + if (!PhysicalLimit::HandleOffset(chunk, state.current_offset, offset.GetIndex(), NumericLimits::Maximum())) { return SinkResultType::NEED_MORE_INPUT; } @@ -157554,15 +159092,14 @@ SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, DataChunk & //===--------------------------------------------------------------------===// class LimitPercentOperatorState : public GlobalSourceState { public: - explicit LimitPercentOperatorState(const PhysicalLimitPercent &op) - : limit(DConstants::INVALID_INDEX), current_offset(0) { + explicit LimitPercentOperatorState(const PhysicalLimitPercent &op) : current_offset(0) { D_ASSERT(op.sink_state); auto &gstate = op.sink_state->Cast(); gstate.data.InitializeScan(scan_state); } ColumnDataScanState scan_state; - idx_t limit; + optional_idx limit; idx_t current_offset; }; @@ -157579,33 +159116,39 @@ SourceResultType PhysicalLimitPercent::GetData(ExecutionContext &context, DataCh auto &limit = state.limit; auto ¤t_offset = state.current_offset; - if (gstate.is_limit_percent_delimited && limit == DConstants::INVALID_INDEX) { + if (!limit.IsValid()) { + if (!gstate.is_limit_set) { + // no limit value and we have not set limit_percent + // we are running LIMIT % with a subquery over an empty table + D_ASSERT(gstate.data.Count() == 0); + return SourceResultType::FINISHED; + } idx_t count = gstate.data.Count(); if (count > 0) { - count += offset; + count += offset.GetIndex(); } if (Value::IsNan(percent_limit) || percent_limit < 0 || percent_limit > 100) { throw OutOfRangeException("Limit percent out of range, should be between 0% and 100%"); } - double limit_dbl = percent_limit / 100 * count; - if (limit_dbl > count) { + auto limit_percentage = idx_t(percent_limit / 100.0 * double(count)); + if (limit_percentage > count) { limit = count; } else { - limit = idx_t(limit_dbl); + limit = idx_t(limit_percentage); } if (limit == 0) { return SourceResultType::FINISHED; } } - if (current_offset >= limit) { + if (current_offset >= limit.GetIndex()) { return SourceResultType::FINISHED; } if (!gstate.data.Scan(state.scan_state, chunk)) { return SourceResultType::FINISHED; } - PhysicalLimit::HandleOffset(chunk, current_offset, 0, limit); + PhysicalLimit::HandleOffset(chunk, current_offset, 0, limit.GetIndex()); return SourceResultType::HAVE_MORE_OUTPUT; } @@ -158515,13 +160058,10 @@ SourceResultType PhysicalSet::GetData(ExecutionContext &context, DataChunk &chun namespace duckdb { -PhysicalStreamingLimit::PhysicalStreamingLimit(vector types, idx_t limit, idx_t offset, - unique_ptr limit_expression, - unique_ptr offset_expression, idx_t estimated_cardinality, - bool parallel) +PhysicalStreamingLimit::PhysicalStreamingLimit(vector types, BoundLimitNode limit_val_p, + BoundLimitNode offset_val_p, idx_t estimated_cardinality, bool parallel) : PhysicalOperator(PhysicalOperatorType::STREAMING_LIMIT, std::move(types), estimated_cardinality), - limit_value(limit), offset_value(offset), limit_expression(std::move(limit_expression)), - offset_expression(std::move(offset_expression)), parallel(parallel) { + limit_val(std::move(limit_val_p)), offset_val(std::move(offset_val_p)), parallel(parallel) { } //===--------------------------------------------------------------------===// @@ -158530,12 +160070,11 @@ PhysicalStreamingLimit::PhysicalStreamingLimit(vector types, idx_t class StreamingLimitOperatorState : public OperatorState { public: explicit StreamingLimitOperatorState(const PhysicalStreamingLimit &op) { - this->limit = op.limit_expression ? DConstants::INVALID_INDEX : op.limit_value; - this->offset = op.offset_expression ? DConstants::INVALID_INDEX : op.offset_value; + PhysicalLimit::SetInitialLimits(op.limit_val, op.offset_val, limit, offset); } - idx_t limit; - idx_t offset; + optional_idx limit; + optional_idx offset; }; class StreamingLimitGlobalState : public GlobalOperatorState { @@ -158562,11 +160101,11 @@ OperatorResultType PhysicalStreamingLimit::Execute(ExecutionContext &context, Da auto &offset = state.offset; idx_t current_offset = gstate.current_offset.fetch_add(input.size()); idx_t max_element; - if (!PhysicalLimit::ComputeOffset(context, input, limit, offset, current_offset, max_element, - limit_expression.get(), offset_expression.get())) { + if (!PhysicalLimit::ComputeOffset(context, input, limit, offset, current_offset, max_element, limit_val, + offset_val)) { return OperatorResultType::FINISHED; } - if (PhysicalLimit::HandleOffset(input, current_offset, offset, limit)) { + if (PhysicalLimit::HandleOffset(input, current_offset, offset.GetIndex(), limit.GetIndex())) { chunk.Reference(input); } return OperatorResultType::NEED_MORE_INPUT; @@ -158744,6 +160283,10 @@ class PhysicalTransaction : public PhysicalOperator { + + + + namespace duckdb { SourceResultType PhysicalTransaction::GetData(ExecutionContext &context, DataChunk &chunk, @@ -158764,6 +160307,14 @@ SourceResultType PhysicalTransaction::GetData(ExecutionContext &context, DataChu // prevent it from being closed after this query, hence // preserving the transaction context for the next query client.transaction.SetAutoCommit(false); + auto &config = DBConfig::GetConfig(context.client); + if (config.options.immediate_transaction_mode) { + // if immediate transaction mode is enabled then start all transactions immediately + auto databases = DatabaseManager::Get(client).GetDatabases(client); + for (auto db : databases) { + context.client.transaction.ActiveTransaction().GetTransaction(db.get()); + } + } } else { throw TransactionException("cannot start a transaction within a transaction"); } @@ -158955,6 +160506,278 @@ SourceResultType PhysicalVacuum::GetData(ExecutionContext &context, DataChunk &c return SourceResultType::FINISHED; } +} // namespace duckdb +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/execution/operator/helper/physical_verify_vector.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + + +namespace duckdb { + +//! The PhysicalVerifyVector operator is a streaming operator that emits the same data as it ingests - but in a +//! different format +// There are different configurations +// * Dictionary: Transform every vector into a dictionary vector where the underlying vector has gaps and is reversed +// i.e. original: FLAT [1, 2, 3] +// modified: BASE: [NULL, 3, NULL, 2, NULL, 1] OFFSETS: [5, 3, 1] +// * Constant: Decompose every DataChunk into single-row constant vectors +// i.e. original: FLAT [1, 2, 3] +// modified: chunk #1 - CONSTANT [1] +// chunk #2 - CONSTANT [2] +// chunk #3 - CONSTANT [3] +// * Sequence & Constant: Decompose every DataChunk into constant or sequence vectors based on the longest possibility +// original: a: [1, 1, 20, 15, 13] b: [1, 10, 100, 101, 102] +// modified: chunk #1 - a: CONSTANT [1, 1] b: DICTIONARY [1, 10] +// chunk #2 - a: DICTIONARY [20, 15, 13] b: SEQUENCE [100, 101, 102] +// * Nested Shuffle: Reshuffle list vectors so that offsets are not contiguous +// original: [[1, 2], [3, 4]] - BASE: [1, 2, 3, 4] LISTS: [offset: 0, length: 2][offset: 2, length: 2] +// modified: [[1, 2], [3, 4]] - BASE: [3, 4, 1, 2] LISTS: [offset: 2, length: 2][offset: 0, length: 2] +class PhysicalVerifyVector : public PhysicalOperator { +public: + static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::VERIFY_VECTOR; + +public: + explicit PhysicalVerifyVector(unique_ptr child); + +public: + unique_ptr GetOperatorState(ExecutionContext &context) const override; + OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk, + GlobalOperatorState &gstate, OperatorState &state) const override; + + bool ParallelOperator() const override { + return true; + } +}; + +} // namespace duckdb + + + + + +namespace duckdb { + +PhysicalVerifyVector::PhysicalVerifyVector(unique_ptr child) + : PhysicalOperator(PhysicalOperatorType::VERIFY_VECTOR, child->types, child->estimated_cardinality) { + children.push_back(std::move(child)); +} + +class VerifyVectorState : public OperatorState { +public: + explicit VerifyVectorState() : const_idx(0) { + } + + idx_t const_idx; +}; + +OperatorResultType VerifyEmitConstantVectors(DataChunk &input, DataChunk &chunk, OperatorState &state_p) { + auto &state = state_p.Cast(); + D_ASSERT(state.const_idx < input.size()); + + // emit constant vectors at the current index + for (idx_t c = 0; c < chunk.ColumnCount(); c++) { + ConstantVector::Reference(chunk.data[c], input.data[c], state.const_idx, 1); + } + chunk.SetCardinality(1); + state.const_idx++; + if (state.const_idx >= input.size()) { + state.const_idx = 0; + return OperatorResultType::NEED_MORE_INPUT; + } + return OperatorResultType::HAVE_MORE_OUTPUT; +} + +OperatorResultType VerifyEmitDictionaryVectors(DataChunk &input, DataChunk &chunk, OperatorState &state) { + chunk.Reference(input); + for (idx_t c = 0; c < chunk.ColumnCount(); c++) { + Vector::DebugTransformToDictionary(chunk.data[c], chunk.size()); + } + return OperatorResultType::NEED_MORE_INPUT; +} + +struct ConstantOrSequenceInfo { + vector values; + bool is_constant = true; +}; + +OperatorResultType VerifyEmitSequenceVector(DataChunk &input, DataChunk &chunk, OperatorState &state_p) { + auto &state = state_p.Cast(); + D_ASSERT(state.const_idx < input.size()); + + // find the longest length sequence or constant vector to emit + vector infos; + idx_t max_length = 0; + for (idx_t c = 0; c < chunk.ColumnCount(); c++) { + bool can_be_sequence = false; + switch (chunk.data[c].GetType().id()) { + case LogicalTypeId::TINYINT: + case LogicalTypeId::SMALLINT: + case LogicalTypeId::INTEGER: + case LogicalTypeId::BIGINT: { + can_be_sequence = true; + break; + } + default: { + break; + } + } + ConstantOrSequenceInfo info; + info.is_constant = true; + for (idx_t k = state.const_idx; k < input.size(); k++) { + auto val = input.data[c].GetValue(k); + if (info.values.empty()) { + info.values.push_back(std::move(val)); + } else if (info.is_constant) { + if (!ValueOperations::DistinctFrom(val, info.values[0])) { + // found the same value! continue + info.values.push_back(std::move(val)); + continue; + } + // not the same value - can we convert this into a sequence vector? + if (!can_be_sequence) { + break; + } + // we can only convert to a sequence if we have only gathered one value + // otherwise we would have multiple identical values here already + if (info.values.size() > 1) { + break; + } + // cannot create a sequence with null values + if (val.IsNull() || info.values[0].IsNull()) { + break; + } + // check if the increment fits in the target type + // i.e. we cannot have a sequence vector with an increment of 200 in `int8_t` + auto increment = hugeint_t(val.GetValue()) - hugeint_t(info.values[0].GetValue()); + bool increment_fits = true; + switch (chunk.data[c].GetType().id()) { + case LogicalTypeId::TINYINT: { + int8_t result; + if (!Hugeint::TryCast(increment, result)) { + increment_fits = false; + } + break; + } + case LogicalTypeId::SMALLINT: { + int16_t result; + if (!Hugeint::TryCast(increment, result)) { + increment_fits = false; + } + break; + } + case LogicalTypeId::INTEGER: { + int32_t result; + if (!Hugeint::TryCast(increment, result)) { + increment_fits = false; + } + break; + } + case LogicalTypeId::BIGINT: { + int64_t result; + if (!Hugeint::TryCast(increment, result)) { + increment_fits = false; + } + break; + } + default: + throw InternalException("Unsupported sequence type"); + } + if (!increment_fits) { + break; + } + info.values.push_back(std::move(val)); + info.is_constant = false; + continue; + } else { + D_ASSERT(info.values.size() >= 2); + // sequence vector - check if this value is on the trajectory + if (val.IsNull()) { + // not on trajectory - this value is null + break; + } + int64_t start = info.values[0].GetValue(); + int64_t increment = info.values[1].GetValue() - start; + int64_t last_value = info.values.back().GetValue(); + if (hugeint_t(val.GetValue()) == hugeint_t(last_value) + hugeint_t(increment)) { + // value still fits in the sequence + info.values.push_back(std::move(val)); + continue; + } + // value no longer fits into the sequence - break + break; + } + } + if (info.values.size() > max_length) { + max_length = info.values.size(); + } + infos.push_back(std::move(info)); + } + // go over each of the columns again and construct either (1) a dictionary vector, or (2) a constant/sequence vector + for (idx_t c = 0; c < chunk.ColumnCount(); c++) { + auto &info = infos[c]; + if (info.values.size() != max_length) { + // dictionary vector + SelectionVector sel(max_length); + for (idx_t k = 0; k < max_length; k++) { + sel.set_index(k, state.const_idx + k); + } + chunk.data[c].Slice(input.data[c], sel, max_length); + } else if (info.is_constant) { + // constant vector + chunk.data[c].Reference(info.values[0]); + } else { + // sequence vector + int64_t start = info.values[0].GetValue(); + int64_t increment = info.values[1].GetValue() - start; + chunk.data[c].Sequence(start, increment, max_length); + } + } + chunk.SetCardinality(max_length); + state.const_idx += max_length; + if (state.const_idx >= input.size()) { + state.const_idx = 0; + return OperatorResultType::NEED_MORE_INPUT; + } + return OperatorResultType::HAVE_MORE_OUTPUT; +} + +OperatorResultType VerifyEmitNestedShuffleVector(DataChunk &input, DataChunk &chunk, OperatorState &state) { + chunk.Reference(input); + for (idx_t c = 0; c < chunk.ColumnCount(); c++) { + Vector::DebugShuffleNestedVector(chunk.data[c], chunk.size()); + } + return OperatorResultType::NEED_MORE_INPUT; +} + +unique_ptr PhysicalVerifyVector::GetOperatorState(ExecutionContext &context) const { + return make_uniq(); +} + +OperatorResultType PhysicalVerifyVector::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk, + GlobalOperatorState &gstate, OperatorState &state) const { +#ifdef DUCKDB_VERIFY_CONSTANT_OPERATOR + return VerifyEmitConstantVectors(input, chunk, state); +#endif +#ifdef DUCKDB_VERIFY_DICTIONARY_OPERATOR + return VerifyEmitDictionaryVectors(input, chunk, state); +#endif +#ifdef DUCKDB_VERIFY_SEQUENCE_OPERATOR + return VerifyEmitSequenceVector(input, chunk, state); +#endif +#ifdef DUCKDB_VERIFY_NESTED_SHUFFLE + return VerifyEmitNestedShuffleVector(input, chunk, state); +#endif + throw InternalException("PhysicalVerifyVector created but no verification code present"); +} + } // namespace duckdb //===----------------------------------------------------------------------===// // DuckDB @@ -159359,6 +161182,9 @@ class PhysicalHashJoin : public PhysicalComparisonJoin { //! Used in perfect hash join PerfectHashJoinStats perfect_join_statistics; +public: + string ParamsToString() const override; + public: // Operator Interface unique_ptr GetOperatorState(ExecutionContext &context) const override; @@ -160013,6 +161839,7 @@ bool AsOfLocalState::Sink(DataChunk &input) { // Compute the join keys lhs_keys.Reset(); lhs_executor.Execute(input, lhs_keys); + lhs_keys.Flatten(); // Combine the NULLs const auto count = input.size(); @@ -161393,6 +163220,7 @@ struct FirstFun { + //===----------------------------------------------------------------------===// // DuckDB // @@ -161786,7 +163614,7 @@ class HashJoinFinalizeTask : public ExecutorTask { public: HashJoinFinalizeTask(shared_ptr event_p, ClientContext &context, HashJoinGlobalSinkState &sink_p, idx_t chunk_idx_from_p, idx_t chunk_idx_to_p, bool parallel_p) - : ExecutorTask(context), event(std::move(event_p)), sink(sink_p), chunk_idx_from(chunk_idx_from_p), + : ExecutorTask(context, std::move(event_p)), sink(sink_p), chunk_idx_from(chunk_idx_from_p), chunk_idx_to(chunk_idx_to_p), parallel(parallel_p) { } @@ -161797,7 +163625,6 @@ class HashJoinFinalizeTask : public ExecutorTask { } private: - shared_ptr event; HashJoinGlobalSinkState &sink; idx_t chunk_idx_from; idx_t chunk_idx_to; @@ -161872,7 +163699,7 @@ class HashJoinRepartitionTask : public ExecutorTask { public: HashJoinRepartitionTask(shared_ptr event_p, ClientContext &context, JoinHashTable &global_ht, JoinHashTable &local_ht) - : ExecutorTask(context), event(std::move(event_p)), global_ht(global_ht), local_ht(local_ht) { + : ExecutorTask(context, std::move(event_p)), global_ht(global_ht), local_ht(local_ht) { } TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override { @@ -161882,8 +163709,6 @@ class HashJoinRepartitionTask : public ExecutorTask { } private: - shared_ptr event; - JoinHashTable &global_ht; JoinHashTable &local_ht; }; @@ -162170,7 +163995,7 @@ class HashJoinGlobalSourceState : public GlobalSourceState { idx_t build_chunks_per_thread; //! For probe synchronization - idx_t probe_chunk_count; + atomic probe_chunk_count; idx_t probe_chunk_done; //! To determine the number of threads @@ -162179,8 +164004,8 @@ class HashJoinGlobalSourceState : public GlobalSourceState { //! For full/outer synchronization idx_t full_outer_chunk_idx; - idx_t full_outer_chunk_count; - idx_t full_outer_chunk_done; + atomic full_outer_chunk_count; + atomic full_outer_chunk_done; idx_t full_outer_chunks_per_thread; vector blocked_tasks; @@ -162584,6 +164409,23 @@ double PhysicalHashJoin::GetProgress(ClientContext &context, GlobalSourceState & return progress * 100.0; } +string PhysicalHashJoin::ParamsToString() const { + string result = EnumUtil::ToString(join_type) + "\n"; + for (auto &it : conditions) { + string op = ExpressionTypeToOperator(it.comparison); + result += it.left->GetName() + " " + op + " " + it.right->GetName() + "\n"; + } + result += "\n[INFOSEPARATOR]\n"; + if (perfect_join_statistics.is_build_small) { + // perfect hash join + result += "Build Min: " + perfect_join_statistics.build_min.ToString() + "\n"; + result += "Build Max: " + perfect_join_statistics.build_max.ToString() + "\n"; + result += "\n[INFOSEPARATOR]\n"; + } + result += StringUtil::Format("EC: %llu\n", estimated_cardinality); + return result; +} + } // namespace duckdb //===----------------------------------------------------------------------===// // DuckDB @@ -165796,6 +167638,7 @@ vector> PhysicalPositionalJoin::GetSources() c + #include namespace duckdb { @@ -165873,7 +167716,7 @@ class RangeJoinMergeTask : public ExecutorTask { public: RangeJoinMergeTask(shared_ptr event_p, ClientContext &context, GlobalSortedTable &table) - : ExecutorTask(context), event(std::move(event_p)), context(context), table(table) { + : ExecutorTask(context, std::move(event_p)), context(context), table(table) { } TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override { @@ -165887,7 +167730,6 @@ class RangeJoinMergeTask : public ExecutorTask { } private: - shared_ptr event; ClientContext &context; GlobalSortedTable &table; }; @@ -166020,7 +167862,12 @@ idx_t PhysicalRangeJoin::LocalSortedTable::MergeNulls(Vector &primary, const vec // Primary is already NULL return count; } - for (auto &v : keys.data) { + for (size_t c = 1; c < keys.data.size(); ++c) { + // Skip comparisons that accept NULLs + if (conditions[c].comparison == ExpressionType::COMPARE_DISTINCT_FROM) { + continue; + } + auto &v = keys.data[c]; if (ConstantVector::IsNull(v)) { // Create a new validity mask to avoid modifying original mask auto &pvalidity = ConstantVector::Validity(primary); @@ -166565,7 +168412,7 @@ SinkCombineResultType PhysicalOrder::Combine(ExecutionContext &context, Operator class PhysicalOrderMergeTask : public ExecutorTask { public: PhysicalOrderMergeTask(shared_ptr event_p, ClientContext &context, OrderGlobalSinkState &state) - : ExecutorTask(context), event(std::move(event_p)), context(context), state(state) { + : ExecutorTask(context, std::move(event_p)), context(context), state(state) { } TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override { @@ -166578,7 +168425,6 @@ class PhysicalOrderMergeTask : public ExecutorTask { } private: - shared_ptr event; ClientContext &context; OrderGlobalSinkState &state; }; @@ -167165,17 +169011,12 @@ bool TopNHeap::CheckBoundaryValues(DataChunk &sort_chunk, DataChunk &payload) { final_count += true_count; } idx_t false_count = remaining_count - true_count; - if (false_count > 0) { + if (!is_last && false_count > 0) { // check what we should continue to check compare_chunk.data[i].Slice(sort_chunk.data[i], false_sel, false_count); remaining_count = VectorOperations::NotDistinctFrom(compare_chunk.data[i], boundary_values.data[i], &false_sel, false_count, &new_remaining_sel, nullptr); - if (is_last) { - memcpy(final_sel.data() + final_count, new_remaining_sel.data(), remaining_count * sizeof(sel_t)); - final_count += remaining_count; - } else { - remaining_sel.Initialize(new_remaining_sel); - } + remaining_sel.Initialize(new_remaining_sel); } else { break; } @@ -167360,7 +169201,7 @@ void CSVRejectsTable::InitializeTable(ClientContext &context, const ReadCSVData //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp +// duckdb/execution/operator/persistent/physical_fixed_batch_copy.hpp // // //===----------------------------------------------------------------------===// @@ -167374,8 +169215,8 @@ void CSVRejectsTable::InitializeTable(ClientContext &context, const ReadCSVData namespace duckdb { +struct FixedRawBatchData; -//! Copy the contents of a query into a table class PhysicalBatchCopyToFile : public PhysicalOperator { public: static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::BATCH_COPY_TO_FILE; @@ -167419,30 +169260,19 @@ class PhysicalBatchCopyToFile : public PhysicalOperator { return true; } -private: - void PrepareBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index, - unique_ptr collection) const; +public: + void AddLocalBatch(ClientContext &context, GlobalSinkState &gstate, LocalSinkState &state) const; + void AddRawBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index, + unique_ptr collection) const; + void RepartitionBatches(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index, + bool final = false) const; void FlushBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index) const; + bool ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p) const; + void ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p) const; SinkFinalizeType FinalFlush(ClientContext &context, GlobalSinkState &gstate_p) const; }; - -struct ActiveFlushGuard { - explicit ActiveFlushGuard(atomic &bool_value_p) : bool_value(bool_value_p) { - bool_value = true; - } - ~ActiveFlushGuard() { - bool_value = false; - } - - atomic &bool_value; -}; - } // namespace duckdb - - - - //===----------------------------------------------------------------------===// // DuckDB // @@ -167517,6 +169347,8 @@ class PhysicalCopyToFile : public PhysicalOperator { static void MoveTmpFile(ClientContext &context, const string &tmp_file_path); + string GetTrimmedPath(ClientContext &context) const; + private: unique_ptr CreateFileState(ClientContext &context, GlobalSinkState &sink) const; }; @@ -167524,55 +169356,340 @@ class PhysicalCopyToFile : public PhysicalOperator { + + + + +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/execution/operator/persistent/batch_memory_manager.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + + + + +namespace duckdb { + +class BatchMemoryManager { +public: + BatchMemoryManager(ClientContext &context, idx_t initial_memory_request) + : context(context), unflushed_memory_usage(0), min_batch_index(0), available_memory(0), + can_increase_memory(true) { + memory_state = TemporaryMemoryManager::Get(context).Register(context); + SetMemorySize(initial_memory_request); + } + +private: + ClientContext &context; + //! Temporary memory state + unique_ptr memory_state; + //! Total memory usage of unflushed rows + atomic unflushed_memory_usage; + //! Minimum batch size + atomic min_batch_index; + //! The available memory for unflushed rows + atomic available_memory; + //! Blocked task lock + mutex blocked_task_lock; + //! The set of blocked tasks + vector blocked_tasks; + //! Whether or not we can request additional memory + bool can_increase_memory; + +public: + void SetMemorySize(idx_t size) { + // request at most 1/4th of all available memory + idx_t total_max_memory = BufferManager::GetBufferManager(context).GetQueryMaxMemory(); + idx_t request_cap = total_max_memory / 4; + + size = MinValue(size, request_cap); + if (size <= available_memory) { + return; + } + + memory_state->SetRemainingSize(context, size); + auto next_reservation = memory_state->GetReservation(); + if (available_memory >= next_reservation) { + // we tried to ask for more memory but were declined + // stop asking for more memory + can_increase_memory = false; + } + available_memory = next_reservation; + } + + void IncreaseMemory() { + if (!can_increase_memory) { + return; + } + SetMemorySize(available_memory * 2); + } + + bool OutOfMemory(idx_t batch_index) { +#ifdef DUCKDB_ALTERNATIVE_VERIFY + // alternative verify - always report that we are out of memory to test this code path + return true; +#else + if (unflushed_memory_usage >= available_memory) { + lock_guard l(blocked_task_lock); + if (batch_index > min_batch_index) { + // exceeded available memory and we are not the minimum batch index- try to increase it + IncreaseMemory(); + if (unflushed_memory_usage >= available_memory) { + // STILL out of memory + return true; + } + } + } + return false; +#endif + } + + void BlockTask(InterruptState &state) { + blocked_tasks.push_back(state); + } + + bool UnblockTasks() { + lock_guard l(blocked_task_lock); + return UnblockTasksInternal(); + } + + bool UnblockTasksInternal() { + if (blocked_tasks.empty()) { + return false; + } + for (auto &entry : blocked_tasks) { + entry.Callback(); + } + blocked_tasks.clear(); + return true; + } + + void UpdateMinBatchIndex(idx_t current_min_batch_index) { + if (min_batch_index >= current_min_batch_index) { + return; + } + lock_guard l(blocked_task_lock); + auto new_batch_index = MaxValue(min_batch_index, current_min_batch_index); + if (new_batch_index != min_batch_index) { + // new batch index! unblock all tasks + min_batch_index = new_batch_index; + UnblockTasksInternal(); + } + } + + idx_t AvailableMemory() const { + return available_memory; + } + + idx_t GetMinimumBatchIndex() const { + return min_batch_index; + } + + mutex &GetBlockedTaskLock() { + return blocked_task_lock; + } + + idx_t GetUnflushedMemory() { + return unflushed_memory_usage; + } + + void IncreaseUnflushedMemory(idx_t memory_increase) { + unflushed_memory_usage += memory_increase; + } + + void ReduceUnflushedMemory(idx_t memory_reduction) { + if (unflushed_memory_usage < memory_reduction) { + throw InternalException("Reducing unflushed memory usage below zero!?"); + } else { + unflushed_memory_usage -= memory_reduction; + } + } + + bool IsMinimumBatchIndex(idx_t batch_index) { + return batch_index <= min_batch_index; + } + + void FinalCheck() { + if (unflushed_memory_usage != 0) { + throw InternalException("Unflushed memory usage is not zero at finalize but %llu", + unflushed_memory_usage.load()); + } + } +}; + +} // namespace duckdb + +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/execution/operator/persistent/batch_task_manager.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + + + + + +namespace duckdb { + +template +class BatchTaskManager { +public: + void AddTask(unique_ptr task) { + lock_guard l(task_lock); + task_queue.push(std::move(task)); + } + + unique_ptr GetTask() { + lock_guard l(task_lock); + if (task_queue.empty()) { + return nullptr; + } + auto entry = std::move(task_queue.front()); + task_queue.pop(); + return entry; + } + + idx_t TaskCount() { + lock_guard l(task_lock); + return task_queue.size(); + } + +private: + mutex task_lock; + //! The task queue for the batch copy to file + queue> task_queue; +}; + +} // namespace duckdb + + #include namespace duckdb { +struct ActiveFlushGuard { + explicit ActiveFlushGuard(atomic &bool_value_p) : bool_value(bool_value_p) { + bool_value = true; + } + ~ActiveFlushGuard() { + bool_value = false; + } + + atomic &bool_value; +}; + PhysicalBatchCopyToFile::PhysicalBatchCopyToFile(vector types, CopyFunction function_p, unique_ptr bind_data_p, idx_t estimated_cardinality) : PhysicalOperator(PhysicalOperatorType::BATCH_COPY_TO_FILE, std::move(types), estimated_cardinality), function(std::move(function_p)), bind_data(std::move(bind_data_p)) { if (!function.flush_batch || !function.prepare_batch) { - throw InternalException( - "PhysicalBatchCopyToFile created for copy function that does not have prepare_batch/flush_batch defined"); + throw InternalException("PhysicalFixedBatchCopy created for copy function that does not have " + "prepare_batch/flush_batch defined"); } } //===--------------------------------------------------------------------===// // States //===--------------------------------------------------------------------===// -class BatchCopyToGlobalState : public GlobalSinkState { +class BatchCopyTask { public: - explicit BatchCopyToGlobalState(unique_ptr global_state) - : rows_copied(0), global_state(std::move(global_state)), any_flushing(false) { + virtual ~BatchCopyTask() { + } + + virtual void Execute(const PhysicalBatchCopyToFile &op, ClientContext &context, GlobalSinkState &gstate_p) = 0; +}; + +struct FixedRawBatchData { + FixedRawBatchData(idx_t memory_usage_p, unique_ptr collection_p) + : memory_usage(memory_usage_p), collection(std::move(collection_p)) { + } + + idx_t memory_usage; + unique_ptr collection; +}; + +struct FixedPreparedBatchData { + idx_t memory_usage; + unique_ptr prepared_data; +}; + +class FixedBatchCopyGlobalState : public GlobalSinkState { +public: + // heuristic - we need at least 4MB of cache space per column per thread we launch + static constexpr const idx_t MINIMUM_MEMORY_PER_COLUMN_PER_THREAD = 4 * 1024 * 1024; + +public: + explicit FixedBatchCopyGlobalState(ClientContext &context_p, unique_ptr global_state, + idx_t minimum_memory_per_thread) + : memory_manager(context_p, minimum_memory_per_thread), rows_copied(0), global_state(std::move(global_state)), + batch_size(0), scheduled_batch_index(0), flushed_batch_index(0), any_flushing(false), any_finished(false), + minimum_memory_per_thread(minimum_memory_per_thread) { } + BatchMemoryManager memory_manager; + BatchTaskManager task_manager; mutex lock; + mutex flush_lock; //! The total number of rows copied to the file atomic rows_copied; //! Global copy state unique_ptr global_state; + //! The desired batch size (if any) + idx_t batch_size; + //! Unpartitioned batches + map> raw_batches; //! The prepared batch data by batch index - ready to flush - map> batch_data; - //! Lock for flushing to disk - mutex flush_lock; - //! Whether or not any threads are flushing (only one thread can flush at a time) + map> batch_data; + //! The index of the latest batch index that has been scheduled + atomic scheduled_batch_index; + //! The index of the latest batch index that has been flushed + atomic flushed_batch_index; + //! Whether or not any thread is flushing atomic any_flushing; + //! Whether or not any threads are finished + atomic any_finished; + //! Minimum memory per thread + idx_t minimum_memory_per_thread; - void AddBatchData(idx_t batch_index, unique_ptr new_batch) { + void AddBatchData(idx_t batch_index, unique_ptr new_batch, idx_t memory_usage) { // move the batch data to the set of prepared batch data lock_guard l(lock); - auto entry = batch_data.insert(make_pair(batch_index, std::move(new_batch))); + auto prepared_data = make_uniq(); + prepared_data->prepared_data = std::move(new_batch); + prepared_data->memory_usage = memory_usage; + auto entry = batch_data.insert(make_pair(batch_index, std::move(prepared_data))); if (!entry.second) { - throw InternalException("Duplicate batch index %llu encountered in PhysicalBatchCopyToFile", batch_index); + throw InternalException("Duplicate batch index %llu encountered in PhysicalFixedBatchCopy", batch_index); } } + + idx_t MaxThreads(idx_t source_max_threads) override { + // try to request 4MB per column per thread + memory_manager.SetMemorySize(source_max_threads * minimum_memory_per_thread); + // cap the concurrent threads working on this task based on the amount of available memory + return MinValue(source_max_threads, memory_manager.AvailableMemory() / minimum_memory_per_thread + 1); + } }; -class BatchCopyToLocalState : public LocalSinkState { +enum class FixedBatchCopyState { SINKING_DATA = 1, PROCESSING_TASKS = 2 }; + +class FixedBatchCopyLocalState : public LocalSinkState { public: - explicit BatchCopyToLocalState(unique_ptr local_state_p) - : local_state(std::move(local_state_p)), rows_copied(0) { + explicit FixedBatchCopyLocalState(unique_ptr local_state_p) + : local_state(std::move(local_state_p)), rows_copied(0), local_memory_usage(0) { } //! Local copy state @@ -167583,12 +169700,17 @@ class BatchCopyToLocalState : public LocalSinkState { ColumnDataAppendState append_state; //! How many rows have been copied in total idx_t rows_copied; + //! Memory usage of the thread-local collection + idx_t local_memory_usage; //! The current batch index optional_idx batch_index; + //! Current task + FixedBatchCopyState current_task = FixedBatchCopyState::SINKING_DATA; void InitializeCollection(ClientContext &context, const PhysicalOperator &op) { - collection = make_uniq(BufferAllocator::Get(context), op.children[0]->types); + collection = make_uniq(context, op.children[0]->types, ColumnDataAllocatorType::HYBRID); collection->InitializeAppend(append_state); + local_memory_usage = 0; } }; @@ -167597,32 +169719,138 @@ class BatchCopyToLocalState : public LocalSinkState { //===--------------------------------------------------------------------===// SinkResultType PhysicalBatchCopyToFile::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const { - auto &state = input.local_state.Cast(); + auto &state = input.local_state.Cast(); + auto &gstate = input.global_state.Cast(); + auto &memory_manager = gstate.memory_manager; + auto batch_index = state.partition_info.batch_index.GetIndex(); + if (state.current_task == FixedBatchCopyState::PROCESSING_TASKS) { + ExecuteTasks(context.client, gstate); + FlushBatchData(context.client, gstate, memory_manager.GetMinimumBatchIndex()); + + if (!memory_manager.IsMinimumBatchIndex(batch_index) && memory_manager.OutOfMemory(batch_index)) { + lock_guard l(memory_manager.GetBlockedTaskLock()); + if (!memory_manager.IsMinimumBatchIndex(batch_index)) { + // no tasks to process, we are not the minimum batch index and we have no memory available to buffer + // block the task for now + memory_manager.BlockTask(input.interrupt_state); + return SinkResultType::BLOCKED; + } + } + state.current_task = FixedBatchCopyState::SINKING_DATA; + } + if (!memory_manager.IsMinimumBatchIndex(batch_index)) { + memory_manager.UpdateMinBatchIndex(state.partition_info.min_batch_index.GetIndex()); + + // we are not processing the current min batch index + // check if we have exceeded the maximum number of unflushed rows + if (memory_manager.OutOfMemory(batch_index)) { + // out-of-memory - stop sinking chunks and instead assist in processing tasks for the minimum batch index + state.current_task = FixedBatchCopyState::PROCESSING_TASKS; + return Sink(context, chunk, input); + } + } if (!state.collection) { state.InitializeCollection(context.client, *this); - state.batch_index = state.partition_info.batch_index.GetIndex(); + state.batch_index = batch_index; } state.rows_copied += chunk.size(); state.collection->Append(state.append_state, chunk); + auto new_memory_usage = state.collection->AllocationSize(); + if (new_memory_usage > state.local_memory_usage) { + // memory usage increased - add to global state + memory_manager.IncreaseUnflushedMemory(new_memory_usage - state.local_memory_usage); + state.local_memory_usage = new_memory_usage; + } else if (new_memory_usage < state.local_memory_usage) { + throw InternalException("PhysicalFixedBatchCopy - memory usage decreased somehow?"); + } return SinkResultType::NEED_MORE_INPUT; } SinkCombineResultType PhysicalBatchCopyToFile::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const { - auto &state = input.local_state.Cast(); - auto &gstate = input.global_state.Cast(); + auto &state = input.local_state.Cast(); + auto &gstate = input.global_state.Cast(); + auto &memory_manager = gstate.memory_manager; gstate.rows_copied += state.rows_copied; + // add any final remaining local batches + AddLocalBatch(context.client, gstate, state); + + if (!gstate.any_finished) { + // signal that this thread is finished processing batches and that we should move on to Finalize + lock_guard l(gstate.lock); + gstate.any_finished = true; + } + memory_manager.UpdateMinBatchIndex(state.partition_info.min_batch_index.GetIndex()); + ExecuteTasks(context.client, gstate); + return SinkCombineResultType::FINISHED; } +//===--------------------------------------------------------------------===// +// ProcessRemainingBatchesEvent +//===--------------------------------------------------------------------===// +class ProcessRemainingBatchesTask : public ExecutorTask { +public: + ProcessRemainingBatchesTask(Executor &executor, shared_ptr event_p, FixedBatchCopyGlobalState &state_p, + ClientContext &context, const PhysicalBatchCopyToFile &op) + : ExecutorTask(executor, std::move(event_p)), op(op), gstate(state_p), context(context) { + } + + TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override { + while (op.ExecuteTask(context, gstate)) { + op.FlushBatchData(context, gstate, 0); + } + event->FinishTask(); + return TaskExecutionResult::TASK_FINISHED; + } + +private: + const PhysicalBatchCopyToFile &op; + FixedBatchCopyGlobalState &gstate; + ClientContext &context; +}; + +class ProcessRemainingBatchesEvent : public BasePipelineEvent { +public: + ProcessRemainingBatchesEvent(const PhysicalBatchCopyToFile &op_p, FixedBatchCopyGlobalState &gstate_p, + Pipeline &pipeline_p, ClientContext &context) + : BasePipelineEvent(pipeline_p), op(op_p), gstate(gstate_p), context(context) { + } + const PhysicalBatchCopyToFile &op; + FixedBatchCopyGlobalState &gstate; + ClientContext &context; + +public: + void Schedule() override { + vector> tasks; + for (idx_t i = 0; i < idx_t(TaskScheduler::GetScheduler(context).NumberOfThreads()); i++) { + auto process_task = + make_uniq(pipeline->executor, shared_from_this(), gstate, context, op); + tasks.push_back(std::move(process_task)); + } + D_ASSERT(!tasks.empty()); + SetTasks(std::move(tasks)); + } + + void FinishEvent() override { + //! Now that all batches are processed we finish flushing the file to disk + op.FinalFlush(context, gstate); + } +}; //===--------------------------------------------------------------------===// // Finalize //===--------------------------------------------------------------------===// SinkFinalizeType PhysicalBatchCopyToFile::FinalFlush(ClientContext &context, GlobalSinkState &gstate_p) const { - auto &gstate = gstate_p.Cast(); - idx_t min_batch_index = idx_t(NumericLimits::Maximum()); + auto &gstate = gstate_p.Cast(); + if (gstate.task_manager.TaskCount() != 0) { + throw InternalException("Unexecuted tasks are remaining in PhysicalFixedBatchCopy::FinalFlush!?"); + } + auto min_batch_index = idx_t(NumericLimits::Maximum()); FlushBatchData(context, gstate_p, min_batch_index); + if (gstate.scheduled_batch_index != gstate.flushed_batch_index) { + throw InternalException("Not all batches were flushed to disk - incomplete file?"); + } if (function.copy_to_finalize) { function.copy_to_finalize(context, *bind_data, *gstate.global_state); @@ -167630,29 +169858,193 @@ SinkFinalizeType PhysicalBatchCopyToFile::FinalFlush(ClientContext &context, Glo PhysicalCopyToFile::MoveTmpFile(context, file_path); } } + gstate.memory_manager.FinalCheck(); return SinkFinalizeType::READY; } SinkFinalizeType PhysicalBatchCopyToFile::Finalize(Pipeline &pipeline, Event &event, ClientContext &context, OperatorSinkFinalizeInput &input) const { - FinalFlush(context, input.global_state); + auto &gstate = input.global_state.Cast(); + auto min_batch_index = idx_t(NumericLimits::Maximum()); + // repartition any remaining batches + RepartitionBatches(context, input.global_state, min_batch_index, true); + // check if we have multiple tasks to execute + if (gstate.task_manager.TaskCount() <= 1) { + // we don't - just execute the remaining task and finish flushing to disk + ExecuteTasks(context, input.global_state); + FinalFlush(context, input.global_state); + } else { + // we have multiple tasks remaining - launch an event to execute the tasks in parallel + auto new_event = make_shared(*this, gstate, pipeline, context); + event.InsertEvent(std::move(new_event)); + } return SinkFinalizeType::READY; } +//===--------------------------------------------------------------------===// +// Tasks +//===--------------------------------------------------------------------===// +class RepartitionedFlushTask : public BatchCopyTask { +public: + RepartitionedFlushTask() { + } + + void Execute(const PhysicalBatchCopyToFile &op, ClientContext &context, GlobalSinkState &gstate_p) override { + op.FlushBatchData(context, gstate_p, 0); + } +}; + +class PrepareBatchTask : public BatchCopyTask { +public: + PrepareBatchTask(idx_t batch_index, unique_ptr batch_data_p) + : batch_index(batch_index), batch_data(std::move(batch_data_p)) { + } + + idx_t batch_index; + unique_ptr batch_data; + + void Execute(const PhysicalBatchCopyToFile &op, ClientContext &context, GlobalSinkState &gstate_p) override { + auto &gstate = gstate_p.Cast(); + auto memory_usage = batch_data->memory_usage; + auto prepared_batch = + op.function.prepare_batch(context, *op.bind_data, *gstate.global_state, std::move(batch_data->collection)); + gstate.AddBatchData(batch_index, std::move(prepared_batch), memory_usage); + if (batch_index == gstate.flushed_batch_index) { + gstate.task_manager.AddTask(make_uniq()); + } + } +}; + //===--------------------------------------------------------------------===// // Batch Data Handling //===--------------------------------------------------------------------===// -void PhysicalBatchCopyToFile::PrepareBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index, - unique_ptr collection) const { - auto &gstate = gstate_p.Cast(); +void PhysicalBatchCopyToFile::AddRawBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index, + unique_ptr raw_batch) const { + auto &gstate = gstate_p.Cast(); - // prepare the batch - auto batch_data = function.prepare_batch(context, *bind_data, *gstate.global_state, std::move(collection)); - gstate.AddBatchData(batch_index, std::move(batch_data)); + // add the batch index to the set of raw batches + lock_guard l(gstate.lock); + auto entry = gstate.raw_batches.insert(make_pair(batch_index, std::move(raw_batch))); + if (!entry.second) { + throw InternalException("Duplicate batch index %llu encountered in PhysicalFixedBatchCopy", batch_index); + } +} + +static bool CorrectSizeForBatch(idx_t collection_size, idx_t desired_size) { + if (desired_size == 0) { + // a batch size of 0 indicates we are happy with any batch size + return true; + } + return idx_t(AbsValue(int64_t(collection_size) - int64_t(desired_size))) < STANDARD_VECTOR_SIZE; +} + +void PhysicalBatchCopyToFile::RepartitionBatches(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index, + bool final) const { + auto &gstate = gstate_p.Cast(); + auto &task_manager = gstate.task_manager; + + // repartition batches until the min index is reached + lock_guard l(gstate.lock); + if (gstate.raw_batches.empty()) { + return; + } + if (!final) { + if (gstate.any_finished) { + // we only repartition in ::NextBatch if all threads are still busy processing batches + // otherwise we might end up repartitioning a lot of data with only a few threads remaining + // which causes erratic performance + return; + } + // if this is not the final flush we first check if we have enough data to merge past the batch threshold + idx_t candidate_rows = 0; + for (auto entry = gstate.raw_batches.begin(); entry != gstate.raw_batches.end(); entry++) { + if (entry->first >= min_index) { + // we have exceeded the minimum batch + break; + } + candidate_rows += entry->second->collection->Count(); + } + if (candidate_rows < gstate.batch_size) { + // not enough rows - cancel! + return; + } + } + // gather all collections we can repartition + idx_t max_batch_index = 0; + vector> raw_batches; + for (auto entry = gstate.raw_batches.begin(); entry != gstate.raw_batches.end();) { + if (entry->first >= min_index) { + break; + } + max_batch_index = entry->first; + raw_batches.push_back(std::move(entry->second)); + entry = gstate.raw_batches.erase(entry); + } + unique_ptr append_batch; + ColumnDataAppendState append_state; + // now perform the actual repartitioning + for (auto ¤t_batch : raw_batches) { + if (!append_batch) { + auto current_count = current_batch->collection->Count(); + if (CorrectSizeForBatch(current_count, gstate.batch_size)) { + // the collection is ~approximately equal to the batch size (off by at most one vector) + // use it directly + task_manager.AddTask( + make_uniq(gstate.scheduled_batch_index++, std::move(current_batch))); + current_batch.reset(); + } else if (current_count < gstate.batch_size) { + // the collection is smaller than the batch size - use it as a starting point + append_batch = std::move(current_batch); + current_batch.reset(); + } else { + // the collection is too large for a batch - we need to repartition + // create an empty collection + auto new_collection = + make_uniq(context, children[0]->types, ColumnDataAllocatorType::HYBRID); + append_batch = make_uniq(0, std::move(new_collection)); + } + if (append_batch) { + append_batch->collection->InitializeAppend(append_state); + } + } + if (!current_batch) { + // we have consumed the collection already - no need to append + continue; + } + auto ¤t_collection = *current_batch->collection; + append_batch->memory_usage += current_batch->memory_usage; + // iterate the collection while appending + for (auto &chunk : current_collection.Chunks()) { + // append the chunk to the collection + append_batch->collection->Append(append_state, chunk); + if (append_batch->collection->Count() < gstate.batch_size) { + // the collection is still under the batch size - continue + continue; + } + // the collection is full - move it to the result and create a new one + task_manager.AddTask(make_uniq(gstate.scheduled_batch_index++, std::move(append_batch))); + + auto new_collection = + make_uniq(context, children[0]->types, ColumnDataAllocatorType::HYBRID); + append_batch = make_uniq(0, std::move(new_collection)); + append_batch->collection->InitializeAppend(append_state); + } + } + if (append_batch && append_batch->collection->Count() > 0) { + // if there are any remaining batches that are not filled up to the batch size + // AND this is not the final collection + // re-add it to the set of raw (to-be-merged) batches + if (final || CorrectSizeForBatch(append_batch->collection->Count(), gstate.batch_size)) { + task_manager.AddTask(make_uniq(gstate.scheduled_batch_index++, std::move(append_batch))); + } else { + gstate.raw_batches[max_batch_index] = std::move(append_batch); + } + } } void PhysicalBatchCopyToFile::FlushBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index) const { - auto &gstate = gstate_p.Cast(); + auto &gstate = gstate_p.Cast(); + auto &memory_manager = gstate.memory_manager; // flush batch data to disk (if there are any to flush) // grab the flush lock - we can only call flush_batch with this lock @@ -167666,45 +170058,92 @@ void PhysicalBatchCopyToFile::FlushBatchData(ClientContext &context, GlobalSinkS } ActiveFlushGuard active_flush(gstate.any_flushing); while (true) { - unique_ptr batch_data; + unique_ptr batch_data; { - // fetch the next batch to flush (if any) lock_guard l(gstate.lock); if (gstate.batch_data.empty()) { // no batch data left to flush break; } auto entry = gstate.batch_data.begin(); - if (entry->first >= min_index) { - // this data is past the min_index - we cannot write it yet + if (entry->first != gstate.flushed_batch_index) { + // this entry is not yet ready to be flushed break; } - if (!entry->second) { - // this batch is in process of being prepared but is not ready yet - break; + if (entry->first < gstate.flushed_batch_index) { + throw InternalException("Batch index was out of order!?"); } batch_data = std::move(entry->second); gstate.batch_data.erase(entry); } - function.flush_batch(context, *bind_data, *gstate.global_state, *batch_data); + function.flush_batch(context, *bind_data, *gstate.global_state, *batch_data->prepared_data); + batch_data->prepared_data.reset(); + memory_manager.ReduceUnflushedMemory(batch_data->memory_usage); + gstate.flushed_batch_index++; + } +} + +//===--------------------------------------------------------------------===// +// Tasks +//===--------------------------------------------------------------------===// +bool PhysicalBatchCopyToFile::ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p) const { + auto &gstate = gstate_p.Cast(); + auto task = gstate.task_manager.GetTask(); + if (!task) { + return false; + } + task->Execute(*this, context, gstate_p); + return true; +} + +void PhysicalBatchCopyToFile::ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p) const { + while (ExecuteTask(context, gstate_p)) { } } //===--------------------------------------------------------------------===// // Next Batch //===--------------------------------------------------------------------===// +void PhysicalBatchCopyToFile::AddLocalBatch(ClientContext &context, GlobalSinkState &gstate_p, + LocalSinkState &lstate) const { + auto &state = lstate.Cast(); + auto &gstate = gstate_p.Cast(); + auto &memory_manager = gstate.memory_manager; + if (!state.collection || state.collection->Count() == 0) { + return; + } + // we finished processing this batch + // start flushing data + auto min_batch_index = state.partition_info.min_batch_index.GetIndex(); + // push the raw batch data into the set of unprocessed batches + auto raw_batch = make_uniq(state.local_memory_usage, std::move(state.collection)); + AddRawBatchData(context, gstate, state.batch_index.GetIndex(), std::move(raw_batch)); + // attempt to repartition to our desired batch size + RepartitionBatches(context, gstate, min_batch_index); + // unblock tasks so they can help process batches (if any are blocked) + auto any_unblocked = memory_manager.UnblockTasks(); + // if any threads were unblocked they can pick up execution of the tasks + // otherwise we will execute a task and flush here + if (!any_unblocked) { + //! Execute a single repartition task + ExecuteTask(context, gstate); + //! Flush batch data to disk (if any is ready) + FlushBatchData(context, gstate, memory_manager.GetMinimumBatchIndex()); + } +} + SinkNextBatchType PhysicalBatchCopyToFile::NextBatch(ExecutionContext &context, OperatorSinkNextBatchInput &input) const { auto &lstate = input.local_state; - auto &gstate_p = input.global_state; - auto &state = lstate.Cast(); - if (state.collection && state.collection->Count() > 0) { - // we finished processing this batch - // start flushing data - auto min_batch_index = lstate.partition_info.min_batch_index.GetIndex(); - PrepareBatchData(context.client, gstate_p, state.batch_index.GetIndex(), std::move(state.collection)); - FlushBatchData(context.client, gstate_p, min_batch_index); - } + auto &state = lstate.Cast(); + auto &gstate = input.global_state.Cast(); + auto &memory_manager = gstate.memory_manager; + + // add the previously finished batch (if any) to the state + AddLocalBatch(context.client, gstate, state); + + // update the minimum batch index + memory_manager.UpdateMinBatchIndex(state.partition_info.min_batch_index.GetIndex()); state.batch_index = lstate.partition_info.batch_index.GetIndex(); state.InitializeCollection(context.client, *this); @@ -167712,11 +170151,17 @@ SinkNextBatchType PhysicalBatchCopyToFile::NextBatch(ExecutionContext &context, } unique_ptr PhysicalBatchCopyToFile::GetLocalSinkState(ExecutionContext &context) const { - return make_uniq(function.copy_to_initialize_local(context, *bind_data)); + return make_uniq(function.copy_to_initialize_local(context, *bind_data)); } unique_ptr PhysicalBatchCopyToFile::GetGlobalSinkState(ClientContext &context) const { - return make_uniq(function.copy_to_initialize_global(context, *bind_data, file_path)); + // request memory based on the minimum amount of memory per column + auto minimum_memory_per_thread = + FixedBatchCopyGlobalState::MINIMUM_MEMORY_PER_COLUMN_PER_THREAD * children[0]->types.size(); + auto result = make_uniq( + context, function.copy_to_initialize_global(context, *bind_data, file_path), minimum_memory_per_thread); + result->batch_size = function.desired_batch_size ? function.desired_batch_size(context, *bind_data) : 0; + return std::move(result); } //===--------------------------------------------------------------------===// @@ -167724,7 +170169,7 @@ unique_ptr PhysicalBatchCopyToFile::GetGlobalSinkState(ClientCo //===--------------------------------------------------------------------===// SourceResultType PhysicalBatchCopyToFile::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const { - auto &g = sink_state->Cast(); + auto &g = sink_state->Cast(); chunk.SetCardinality(1); chunk.SetValue(0, 0, Value::BIGINT(g.rows_copied)); @@ -167926,6 +170371,10 @@ class PhysicalBatchInsert : public PhysicalOperator { bool ParallelSink() const override { return true; } + +private: + bool ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const; + void ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const; }; } // namespace duckdb @@ -167941,6 +170390,7 @@ class PhysicalBatchInsert : public PhysicalOperator { + namespace duckdb { PhysicalBatchInsert::PhysicalBatchInsert(vector types, TableCatalogEntry &table, @@ -167959,9 +170409,8 @@ PhysicalBatchInsert::PhysicalBatchInsert(LogicalOperator &op, SchemaCatalogEntry } //===--------------------------------------------------------------------===// -// Sink +// CollectionMerger //===--------------------------------------------------------------------===// - class CollectionMerger { public: explicit CollectionMerger(ClientContext &context) : context(context) { @@ -168028,25 +170477,40 @@ class CollectionMerger { enum class RowGroupBatchType : uint8_t { FLUSHED, NOT_FLUSHED }; struct RowGroupBatchEntry { RowGroupBatchEntry(idx_t batch_idx, unique_ptr collection_p, RowGroupBatchType type) - : batch_idx(batch_idx), total_rows(collection_p->GetTotalRows()), collection(std::move(collection_p)), - type(type) { + : batch_idx(batch_idx), total_rows(collection_p->GetTotalRows()), unflushed_memory(0), + collection(std::move(collection_p)), type(type) { + if (type == RowGroupBatchType::NOT_FLUSHED) { + unflushed_memory = collection->GetAllocationSize(); + } } idx_t batch_idx; idx_t total_rows; + idx_t unflushed_memory; unique_ptr collection; RowGroupBatchType type; }; -class BatchInsertGlobalState : public GlobalSinkState { +//===--------------------------------------------------------------------===// +// States +//===--------------------------------------------------------------------===// +class BatchInsertTask { public: - static constexpr const idx_t BATCH_FLUSH_THRESHOLD = LocalStorage::MERGE_THRESHOLD * 3; + virtual ~BatchInsertTask() { + } + + virtual void Execute(const PhysicalBatchInsert &op, ClientContext &context, GlobalSinkState &gstate_p, + LocalSinkState &lstate_p) = 0; +}; +class BatchInsertGlobalState : public GlobalSinkState { public: - explicit BatchInsertGlobalState(DuckTableEntry &table) - : table(table), insert_count(0), optimistically_written(false) { + explicit BatchInsertGlobalState(ClientContext &context, DuckTableEntry &table, idx_t initial_memory) + : memory_manager(context, initial_memory), table(table), insert_count(0), optimistically_written(false) { } + BatchMemoryManager memory_manager; + BatchTaskManager task_manager; mutex lock; DuckTableEntry &table; idx_t insert_count; @@ -168054,140 +170518,21 @@ class BatchInsertGlobalState : public GlobalSinkState { idx_t next_start = 0; atomic optimistically_written; - void FindMergeCollections(idx_t min_batch_index, optional_idx &merged_batch_index, - vector> &result) { - bool merge = false; - idx_t start_index = next_start; - idx_t current_idx; - idx_t total_count = 0; - for (current_idx = start_index; current_idx < collections.size(); current_idx++) { - auto &entry = collections[current_idx]; - if (entry.batch_idx >= min_batch_index) { - // this entry is AFTER the min_batch_index - // we might still find new entries! - break; - } - if (entry.type == RowGroupBatchType::FLUSHED) { - // already flushed: cannot flush anything here - if (total_count > 0) { - merge = true; - break; - } - start_index = current_idx + 1; - if (start_index > next_start) { - // avoid checking this segment again in the future - next_start = start_index; - } - total_count = 0; - continue; - } - // not flushed - add to set of indexes to flush - total_count += entry.total_rows; - if (total_count >= BATCH_FLUSH_THRESHOLD) { - merge = true; - break; - } - } - if (merge && total_count > 0) { - D_ASSERT(current_idx > start_index); - merged_batch_index = collections[start_index].batch_idx; - for (idx_t idx = start_index; idx < current_idx; idx++) { - auto &entry = collections[idx]; - if (!entry.collection || entry.type == RowGroupBatchType::FLUSHED) { - throw InternalException("Adding a row group collection that should not be flushed"); - } - result.push_back(std::move(entry.collection)); - entry.total_rows = total_count; - entry.type = RowGroupBatchType::FLUSHED; - } - if (start_index + 1 < current_idx) { - // erase all entries except the first one - collections.erase(collections.begin() + start_index + 1, collections.begin() + current_idx); - } - } - } - + static bool ReadyToMerge(idx_t count); + void ScheduleMergeTasks(idx_t min_batch_index); unique_ptr MergeCollections(ClientContext &context, - vector> merge_collections, - OptimisticDataWriter &writer) { - D_ASSERT(!merge_collections.empty()); - CollectionMerger merger(context); - for (auto &collection : merge_collections) { - merger.AddCollection(std::move(collection)); - } - optimistically_written = true; - return merger.Flush(writer); - } - + vector merge_collections, + OptimisticDataWriter &writer); void AddCollection(ClientContext &context, idx_t batch_index, idx_t min_batch_index, unique_ptr current_collection, - optional_ptr writer = nullptr, - optional_ptr written_to_disk = nullptr) { - if (batch_index < min_batch_index) { - throw InternalException( - "Batch index of the added collection (%llu) is smaller than the min batch index (%llu)", batch_index, - min_batch_index); - } - auto new_count = current_collection->GetTotalRows(); - auto batch_type = - new_count < Storage::ROW_GROUP_SIZE ? RowGroupBatchType::NOT_FLUSHED : RowGroupBatchType::FLUSHED; - if (batch_type == RowGroupBatchType::FLUSHED && writer) { - writer->WriteLastRowGroup(*current_collection); - } - optional_idx merged_batch_index; - vector> merge_collections; - { - lock_guard l(lock); - insert_count += new_count; - - // add the collection to the batch index - RowGroupBatchEntry new_entry(batch_index, std::move(current_collection), batch_type); - - auto it = std::lower_bound( - collections.begin(), collections.end(), new_entry, - [&](const RowGroupBatchEntry &a, const RowGroupBatchEntry &b) { return a.batch_idx < b.batch_idx; }); - if (it != collections.end() && it->batch_idx == new_entry.batch_idx) { - throw InternalException( - "PhysicalBatchInsert::AddCollection error: batch index %d is present in multiple " - "collections. This occurs when " - "batch indexes are not uniquely distributed over threads", - batch_index); - } - collections.insert(it, std::move(new_entry)); - if (writer) { - FindMergeCollections(min_batch_index, merged_batch_index, merge_collections); - } - } - if (!merge_collections.empty()) { - // merge together the collections - D_ASSERT(writer); - auto final_collection = MergeCollections(context, std::move(merge_collections), *writer); - if (written_to_disk) { - *written_to_disk = true; - } - // add the merged-together collection to the set of batch indexes - { - lock_guard l(lock); - RowGroupBatchEntry new_entry(merged_batch_index.GetIndex(), std::move(final_collection), - RowGroupBatchType::FLUSHED); - auto it = std::lower_bound(collections.begin(), collections.end(), new_entry, - [&](const RowGroupBatchEntry &a, const RowGroupBatchEntry &b) { - return a.batch_idx < b.batch_idx; - }); - if (it->batch_idx != merged_batch_index.GetIndex()) { - throw InternalException("Merged batch index was no longer present in collection"); - } - it->collection = std::move(new_entry.collection); - } - } - } + optional_ptr writer = nullptr); }; class BatchInsertLocalState : public LocalSinkState { public: BatchInsertLocalState(ClientContext &context, const vector &types, const vector> &bound_defaults) - : default_executor(context, bound_defaults), written_to_disk(false) { + : default_executor(context, bound_defaults) { insert_chunk.Initialize(Allocator::Get(context), types); } @@ -168197,7 +170542,6 @@ class BatchInsertLocalState : public LocalSinkState { TableAppendState current_append_state; unique_ptr current_collection; optional_ptr writer; - bool written_to_disk; void CreateNewCollection(DuckTableEntry &table, const vector &insert_types) { auto &table_info = table.GetStorage().info; @@ -168205,10 +170549,199 @@ class BatchInsertLocalState : public LocalSinkState { current_collection = make_uniq(table_info, block_manager, insert_types, MAX_ROW_ID); current_collection->InitializeEmpty(); current_collection->InitializeAppend(current_append_state); - written_to_disk = false; } }; +//===--------------------------------------------------------------------===// +// Merge Task +//===--------------------------------------------------------------------===// +class MergeCollectionTask : public BatchInsertTask { +public: + MergeCollectionTask(vector merge_collections_p, idx_t merged_batch_index) + : merge_collections(std::move(merge_collections_p)), merged_batch_index(merged_batch_index) { + } + + vector merge_collections; + idx_t merged_batch_index; + + void Execute(const PhysicalBatchInsert &op, ClientContext &context, GlobalSinkState &gstate_p, + LocalSinkState &lstate_p) override { + auto &gstate = gstate_p.Cast(); + auto &lstate = lstate_p.Cast(); + // merge together the collections + D_ASSERT(lstate.writer); + auto final_collection = gstate.MergeCollections(context, std::move(merge_collections), *lstate.writer); + // add the merged-together collection to the set of batch indexes + lock_guard l(gstate.lock); + RowGroupBatchEntry new_entry(merged_batch_index, std::move(final_collection), RowGroupBatchType::FLUSHED); + auto it = std::lower_bound( + gstate.collections.begin(), gstate.collections.end(), new_entry, + [&](const RowGroupBatchEntry &a, const RowGroupBatchEntry &b) { return a.batch_idx < b.batch_idx; }); + if (it->batch_idx != merged_batch_index) { + throw InternalException("Merged batch index was no longer present in collection"); + } + it->collection = std::move(new_entry.collection); + } +}; + +struct BatchMergeTask { + explicit BatchMergeTask(idx_t start_index) : start_index(start_index), end_index(0), total_count(0) { + } + + idx_t start_index; + idx_t end_index; + idx_t total_count; +}; + +bool BatchInsertGlobalState::ReadyToMerge(idx_t count) { + // we try to merge so the count fits nicely into row groups + if (count >= Storage::ROW_GROUP_SIZE / 10 * 9 && count <= Storage::ROW_GROUP_SIZE) { + // 90%-100% of row group size + return true; + } + if (count >= Storage::ROW_GROUP_SIZE / 10 * 18 && count <= Storage::ROW_GROUP_SIZE * 2) { + // 180%-200% of row group size + return true; + } + if (count >= Storage::ROW_GROUP_SIZE / 10 * 27 && count <= Storage::ROW_GROUP_SIZE * 3) { + // 270%-300% of row group size + return true; + } + if (count >= Storage::ROW_GROUP_SIZE / 10 * 36) { + // >360% of row group size + return true; + } + return false; +} + +void BatchInsertGlobalState::ScheduleMergeTasks(idx_t min_batch_index) { + idx_t current_idx; + + vector to_be_scheduled_tasks; + + BatchMergeTask current_task(next_start); + for (current_idx = current_task.start_index; current_idx < collections.size(); current_idx++) { + auto &entry = collections[current_idx]; + if (entry.batch_idx > min_batch_index) { + // this entry is AFTER the min_batch_index + // finished + if (ReadyToMerge(current_task.total_count)) { + current_task.end_index = current_idx; + to_be_scheduled_tasks.push_back(current_task); + } + break; + } + if (entry.type == RowGroupBatchType::FLUSHED) { + // already flushed: cannot flush anything here + if (current_task.total_count > 0) { + current_task.end_index = current_idx; + to_be_scheduled_tasks.push_back(current_task); + } + current_task.start_index = current_idx + 1; + if (current_task.start_index > next_start) { + // avoid checking this segment again in the future + next_start = current_task.start_index; + } + current_task.total_count = 0; + continue; + } + // not flushed - add to set of indexes to flush + current_task.total_count += entry.total_rows; + if (ReadyToMerge(current_task.total_count)) { + // create a task to merge these collections + current_task.end_index = current_idx + 1; + to_be_scheduled_tasks.push_back(current_task); + current_task.start_index = current_idx + 1; + current_task.total_count = 0; + } + } + + if (to_be_scheduled_tasks.empty()) { + return; + } + for (auto &scheduled_task : to_be_scheduled_tasks) { + D_ASSERT(scheduled_task.total_count > 0); + D_ASSERT(current_idx > scheduled_task.start_index); + idx_t merged_batch_index = collections[scheduled_task.start_index].batch_idx; + vector merge_collections; + for (idx_t idx = scheduled_task.start_index; idx < scheduled_task.end_index; idx++) { + auto &entry = collections[idx]; + if (!entry.collection || entry.type == RowGroupBatchType::FLUSHED) { + throw InternalException("Adding a row group collection that should not be flushed"); + } + RowGroupBatchEntry added_entry(collections[scheduled_task.start_index].batch_idx, + std::move(entry.collection), RowGroupBatchType::FLUSHED); + added_entry.unflushed_memory = entry.unflushed_memory; + merge_collections.push_back(std::move(added_entry)); + entry.total_rows = scheduled_task.total_count; + entry.type = RowGroupBatchType::FLUSHED; + } + task_manager.AddTask(make_uniq(std::move(merge_collections), merged_batch_index)); + } + // erase in reverse order + for (idx_t i = to_be_scheduled_tasks.size(); i > 0; i--) { + auto &scheduled_task = to_be_scheduled_tasks[i - 1]; + if (scheduled_task.start_index + 1 < scheduled_task.end_index) { + // erase all entries except the first one + collections.erase(collections.begin() + scheduled_task.start_index + 1, + collections.begin() + scheduled_task.end_index); + } + } +} + +unique_ptr BatchInsertGlobalState::MergeCollections(ClientContext &context, + vector merge_collections, + OptimisticDataWriter &writer) { + D_ASSERT(!merge_collections.empty()); + CollectionMerger merger(context); + idx_t written_data = 0; + for (auto &entry : merge_collections) { + merger.AddCollection(std::move(entry.collection)); + written_data += entry.unflushed_memory; + } + optimistically_written = true; + memory_manager.ReduceUnflushedMemory(written_data); + return merger.Flush(writer); +} + +void BatchInsertGlobalState::AddCollection(ClientContext &context, idx_t batch_index, idx_t min_batch_index, + unique_ptr current_collection, + optional_ptr writer) { + if (batch_index < min_batch_index) { + throw InternalException("Batch index of the added collection (%llu) is smaller than the min batch index (%llu)", + batch_index, min_batch_index); + } + auto new_count = current_collection->GetTotalRows(); + auto batch_type = new_count < Storage::ROW_GROUP_SIZE ? RowGroupBatchType::NOT_FLUSHED : RowGroupBatchType::FLUSHED; + if (batch_type == RowGroupBatchType::FLUSHED && writer) { + writer->WriteLastRowGroup(*current_collection); + } + lock_guard l(lock); + insert_count += new_count; + // add the collection to the batch index + RowGroupBatchEntry new_entry(batch_index, std::move(current_collection), batch_type); + if (batch_type == RowGroupBatchType::NOT_FLUSHED) { + memory_manager.IncreaseUnflushedMemory(new_entry.unflushed_memory); + } + + auto it = std::lower_bound( + collections.begin(), collections.end(), new_entry, + [&](const RowGroupBatchEntry &a, const RowGroupBatchEntry &b) { return a.batch_idx < b.batch_idx; }); + if (it != collections.end() && it->batch_idx == new_entry.batch_idx) { + throw InternalException("PhysicalBatchInsert::AddCollection error: batch index %d is present in multiple " + "collections. This occurs when " + "batch indexes are not uniquely distributed over threads", + batch_index); + } + collections.insert(it, std::move(new_entry)); + if (writer) { + ScheduleMergeTasks(min_batch_index); + } +} + +//===--------------------------------------------------------------------===// +// States +//===--------------------------------------------------------------------===// unique_ptr PhysicalBatchInsert::GetGlobalSinkState(ClientContext &context) const { optional_ptr table; if (info) { @@ -168222,7 +170755,10 @@ unique_ptr PhysicalBatchInsert::GetGlobalSinkState(ClientContex D_ASSERT(insert_table->IsDuckTable()); table = insert_table.get_mutable(); } - auto result = make_uniq(table->Cast()); + // heuristic - we start off by allocating 4MB of cache space per column + static constexpr const idx_t MINIMUM_MEMORY_PER_COLUMN = 4 * 1024 * 1024; + auto initial_memory = table->GetColumns().PhysicalColumnCount() * MINIMUM_MEMORY_PER_COLUMN; + auto result = make_uniq(context, table->Cast(), initial_memory); return std::move(result); } @@ -168230,11 +170766,34 @@ unique_ptr PhysicalBatchInsert::GetLocalSinkState(ExecutionConte return make_uniq(context.client, insert_types, bound_defaults); } +//===--------------------------------------------------------------------===// +// Tasks +//===--------------------------------------------------------------------===// +bool PhysicalBatchInsert::ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p, + LocalSinkState &lstate_p) const { + auto &gstate = gstate_p.Cast(); + auto task = gstate.task_manager.GetTask(); + if (!task) { + return false; + } + task->Execute(*this, context, gstate_p, lstate_p); + return true; +} + +void PhysicalBatchInsert::ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p, + LocalSinkState &lstate_p) const { + while (ExecuteTask(context, gstate_p, lstate_p)) { + } +} + +//===--------------------------------------------------------------------===// +// NextBatch +//===--------------------------------------------------------------------===// SinkNextBatchType PhysicalBatchInsert::NextBatch(ExecutionContext &context, OperatorSinkNextBatchInput &input) const { auto &gstate = input.global_state.Cast(); auto &lstate = input.local_state.Cast(); + auto &memory_manager = gstate.memory_manager; - auto &table = gstate.table; auto batch_index = lstate.partition_info.batch_index.GetIndex(); if (lstate.current_collection) { if (lstate.current_index == batch_index) { @@ -168244,26 +170803,61 @@ SinkNextBatchType PhysicalBatchInsert::NextBatch(ExecutionContext &context, Oper TransactionData tdata(0, 0); lstate.current_collection->FinalizeAppend(tdata, lstate.current_append_state); gstate.AddCollection(context.client, lstate.current_index, lstate.partition_info.min_batch_index.GetIndex(), - std::move(lstate.current_collection), lstate.writer, &lstate.written_to_disk); - lstate.CreateNewCollection(table, insert_types); + std::move(lstate.current_collection), lstate.writer); + + auto any_unblocked = memory_manager.UnblockTasks(); + if (!any_unblocked) { + ExecuteTasks(context.client, gstate, lstate); + } + lstate.current_collection.reset(); } lstate.current_index = batch_index; + + // unblock any blocked tasks + memory_manager.UnblockTasks(); + return SinkNextBatchType::READY; } +//===--------------------------------------------------------------------===// +// Sink +//===--------------------------------------------------------------------===// SinkResultType PhysicalBatchInsert::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const { auto &gstate = input.global_state.Cast(); auto &lstate = input.local_state.Cast(); + auto &memory_manager = gstate.memory_manager; auto &table = gstate.table; PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk); auto batch_index = lstate.partition_info.batch_index.GetIndex(); + // check if we should process this batch + if (!memory_manager.IsMinimumBatchIndex(batch_index)) { + memory_manager.UpdateMinBatchIndex(lstate.partition_info.min_batch_index.GetIndex()); + + // we are not processing the current min batch index + // check if we have exceeded the maximum number of unflushed rows + if (memory_manager.OutOfMemory(batch_index)) { + // out-of-memory + // execute tasks while we wait (if any are available) + ExecuteTasks(context.client, gstate, lstate); + + lock_guard l(memory_manager.GetBlockedTaskLock()); + if (!memory_manager.IsMinimumBatchIndex(batch_index)) { + // we are not the minimum batch index and we have no memory available to buffer - block the task for + // now + memory_manager.BlockTask(input.interrupt_state); + return SinkResultType::BLOCKED; + } + } + } if (!lstate.current_collection) { lock_guard l(gstate.lock); // no collection yet: create a new one lstate.CreateNewCollection(table, insert_types); - lstate.writer = &table.GetStorage().CreateOptimisticWriter(context.client); + if (!lstate.writer) { + lstate.writer = &table.GetStorage().CreateOptimisticWriter(context.client); + } } if (lstate.current_index != batch_index) { @@ -168276,39 +170870,49 @@ SinkResultType PhysicalBatchInsert::Sink(ExecutionContext &context, DataChunk &c if (new_row_group) { // we have already written to disk - flush the next row group as well lstate.writer->WriteNewRowGroup(*lstate.current_collection); - lstate.written_to_disk = true; } return SinkResultType::NEED_MORE_INPUT; } +//===--------------------------------------------------------------------===// +// Combine +//===--------------------------------------------------------------------===// SinkCombineResultType PhysicalBatchInsert::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const { auto &gstate = input.global_state.Cast(); auto &lstate = input.local_state.Cast(); + auto &memory_manager = gstate.memory_manager; auto &client_profiler = QueryProfiler::Get(context.client); context.thread.profiler.Flush(*this, lstate.default_executor, "default_executor", 1); client_profiler.Flush(context.thread.profiler); - if (!lstate.current_collection) { - return SinkCombineResultType::FINISHED; - } + memory_manager.UpdateMinBatchIndex(lstate.partition_info.min_batch_index.GetIndex()); - if (lstate.current_collection->GetTotalRows() > 0) { + if (lstate.current_collection) { TransactionData tdata(0, 0); lstate.current_collection->FinalizeAppend(tdata, lstate.current_append_state); - gstate.AddCollection(context.client, lstate.current_index, lstate.partition_info.min_batch_index.GetIndex(), - std::move(lstate.current_collection)); + if (lstate.current_collection->GetTotalRows() > 0) { + gstate.AddCollection(context.client, lstate.current_index, lstate.partition_info.min_batch_index.GetIndex(), + std::move(lstate.current_collection)); + } } - { + if (lstate.writer) { lock_guard l(gstate.lock); gstate.table.GetStorage().FinalizeOptimisticWriter(context.client, *lstate.writer); } + // unblock any blocked tasks + memory_manager.UnblockTasks(); + return SinkCombineResultType::FINISHED; } +//===--------------------------------------------------------------------===// +// Finalize +//===--------------------------------------------------------------------===// SinkFinalizeType PhysicalBatchInsert::Finalize(Pipeline &pipeline, Event &event, ClientContext &context, OperatorSinkFinalizeInput &input) const { auto &gstate = input.global_state.Cast(); + auto &memory_manager = gstate.memory_manager; if (gstate.optimistically_written || gstate.insert_count >= LocalStorage::MERGE_THRESHOLD) { // we have written data to disk optimistically or are inserting a large amount of data @@ -168324,6 +170928,7 @@ SinkFinalizeType PhysicalBatchInsert::Finalize(Pipeline &pipeline, Event &event, current_merger = make_uniq(context); } current_merger->AddCollection(std::move(entry.collection)); + memory_manager.ReduceUnflushedMemory(entry.unflushed_memory); } else { // this collection has been flushed: it does not need to be merged // create a separate collection merger only for this entry @@ -168348,12 +170953,12 @@ SinkFinalizeType PhysicalBatchInsert::Finalize(Pipeline &pipeline, Event &event, for (auto &merger : mergers) { final_collections.push_back(merger->Flush(writer)); } - storage.FinalizeOptimisticWriter(context, writer); // finally, merge the row groups into the local storage for (auto &collection : final_collections) { storage.LocalMerge(context, *collection); } + storage.FinalizeOptimisticWriter(context, writer); } else { // we are writing a small amount of data to disk // append directly to transaction local storage @@ -168363,6 +170968,11 @@ SinkFinalizeType PhysicalBatchInsert::Finalize(Pipeline &pipeline, Event &event, storage.InitializeLocalAppend(append_state, context); auto &transaction = DuckTransaction::Get(context, table.catalog); for (auto &entry : gstate.collections) { + if (entry.type != RowGroupBatchType::NOT_FLUSHED) { + throw InternalException("Encountered a flushed batch"); + } + + memory_manager.ReduceUnflushedMemory(entry.unflushed_memory); entry.collection->Scan(transaction, [&](DataChunk &insert_chunk) { storage.LocalAppend(append_state, table, context, insert_chunk); return true; @@ -168370,6 +170980,7 @@ SinkFinalizeType PhysicalBatchInsert::Finalize(Pipeline &pipeline, Event &event, } storage.FinalizeLocalAppend(append_state); } + memory_manager.FinalCheck(); return SinkFinalizeType::READY; } @@ -168592,6 +171203,37 @@ SourceResultType PhysicalCopyDatabase::GetData(ExecutionContext &context, DataCh namespace duckdb { +struct PartitionWriteInfo { + unique_ptr global_state; +}; + +struct VectorOfValuesHashFunction { + uint64_t operator()(const vector &values) const { + hash_t result = 0; + for (auto &val : values) { + result ^= val.Hash(); + } + return result; + } +}; + +struct VectorOfValuesEquality { + bool operator()(const vector &a, const vector &b) const { + if (a.size() != b.size()) { + return false; + } + for (idx_t i = 0; i < a.size(); i++) { + if (ValueOperations::DistinctFrom(a[i], b[i])) { + return false; + } + } + return true; + } +}; + +template +using vector_of_value_map_t = unordered_map, T, VectorOfValuesHashFunction, VectorOfValuesEquality>; + class CopyToFunctionGlobalState : public GlobalSinkState { public: explicit CopyToFunctionGlobalState(unique_ptr global_state) @@ -168605,8 +171247,109 @@ class CopyToFunctionGlobalState : public GlobalSinkState { //! shared state for HivePartitionedColumnData shared_ptr partition_state; + + static void CreateDir(const string &dir_path, FileSystem &fs) { + if (!fs.DirectoryExists(dir_path)) { + fs.CreateDirectory(dir_path); + } + } + + static void CreateDirectories(const vector &cols, const vector &names, const vector &values, + string path, FileSystem &fs) { + CreateDir(path, fs); + + for (idx_t i = 0; i < cols.size(); i++) { + const auto &partition_col_name = names[cols[i]]; + const auto &partition_value = values[i]; + string p_dir = partition_col_name + "=" + partition_value.ToString(); + path = fs.JoinPath(path, p_dir); + CreateDir(path, fs); + } + } + + void CreatePartitionDirectories(ClientContext &context, const PhysicalCopyToFile &op) { + auto &fs = FileSystem::GetFileSystem(context); + + auto trimmed_path = op.GetTrimmedPath(context); + + auto l = lock.GetExclusiveLock(); + lock_guard global_lock_on_partition_state(partition_state->lock); + const auto &global_partitions = partition_state->partitions; + // global_partitions have partitions added only at the back, so it's fine to only traverse the last part + + for (idx_t i = created_directories; i < global_partitions.size(); i++) { + CreateDirectories(op.partition_columns, op.names, global_partitions[i]->first.values, trimmed_path, fs); + } + created_directories = global_partitions.size(); + } + + static string GetDirectory(const vector &cols, const vector &names, const vector &values, + string path, FileSystem &fs) { + for (idx_t i = 0; i < cols.size(); i++) { + const auto &partition_col_name = names[cols[i]]; + const auto &partition_value = values[i]; + string p_dir = partition_col_name + "=" + partition_value.ToString(); + path = fs.JoinPath(path, p_dir); + } + return path; + } + + void FinalizePartition(ClientContext &context, const PhysicalCopyToFile &op, PartitionWriteInfo &info) { + if (!info.global_state) { + // already finalized + return; + } + // finalize the partition + op.function.copy_to_finalize(context, *op.bind_data, *info.global_state); + info.global_state.reset(); + } + + void FinalizePartitions(ClientContext &context, const PhysicalCopyToFile &op) { + // finalize any remaining partitions + for (auto &entry : active_partitioned_writes) { + FinalizePartition(context, op, *entry.second); + } + } + + PartitionWriteInfo &GetPartitionWriteInfo(ExecutionContext &context, const PhysicalCopyToFile &op, + const vector &values) { + auto l = lock.GetExclusiveLock(); + // check if we have already started writing this partition + auto entry = active_partitioned_writes.find(values); + if (entry != active_partitioned_writes.end()) { + // we have - continue writing in this partition + return *entry->second; + } + auto &fs = FileSystem::GetFileSystem(context.client); + // Create a writer for the current file + auto trimmed_path = op.GetTrimmedPath(context.client); + string hive_path = GetDirectory(op.partition_columns, op.names, values, trimmed_path, fs); + string full_path(op.filename_pattern.CreateFilename(fs, hive_path, op.file_extension, 0)); + if (fs.FileExists(full_path) && !op.overwrite_or_ignore) { + throw IOException("failed to create %s, file exists! Enable OVERWRITE_OR_IGNORE option to force writing", + full_path); + } + // initialize writes + auto info = make_uniq(); + info->global_state = op.function.copy_to_initialize_global(context.client, *op.bind_data, full_path); + auto &result = *info; + // store in active write map + active_partitioned_writes.insert(make_pair(values, std::move(info))); + return result; + } + +private: + //! The active writes per partition (for partitioned write) + vector_of_value_map_t> active_partitioned_writes; }; +string PhysicalCopyToFile::GetTrimmedPath(ClientContext &context) const { + auto &fs = FileSystem::GetFileSystem(context); + string trimmed_path = file_path; + StringUtil::RTrim(trimmed_path, fs.PathSeparator(trimmed_path)); + return trimmed_path; +} + class CopyToFunctionLocalState : public LocalSinkState { public: explicit CopyToFunctionLocalState(unique_ptr local_state) @@ -168620,6 +171363,63 @@ class CopyToFunctionLocalState : public LocalSinkState { unique_ptr part_buffer_append_state; idx_t writer_offset; + idx_t append_count = 0; + + void InitializeAppendState(ClientContext &context, const PhysicalCopyToFile &op, + CopyToFunctionGlobalState &gstate) { + part_buffer = make_uniq(context, op.expected_types, op.partition_columns, + gstate.partition_state); + part_buffer_append_state = make_uniq(); + part_buffer->InitializeAppendState(*part_buffer_append_state); + append_count = 0; + } + + void AppendToPartition(ExecutionContext &context, const PhysicalCopyToFile &op, CopyToFunctionGlobalState &g, + DataChunk &chunk) { + if (!part_buffer) { + // re-initialize the append + InitializeAppendState(context.client, op, g); + } + part_buffer->Append(*part_buffer_append_state, chunk); + append_count += chunk.size(); + if (append_count >= ClientConfig::GetConfig(context.client).partitioned_write_flush_threshold) { + // flush all cached partitions + FlushPartitions(context, op, g); + } + } + + void ResetAppendState() { + part_buffer_append_state.reset(); + part_buffer.reset(); + append_count = 0; + } + + void FlushPartitions(ExecutionContext &context, const PhysicalCopyToFile &op, CopyToFunctionGlobalState &g) { + if (!part_buffer) { + return; + } + part_buffer->FlushAppendState(*part_buffer_append_state); + auto &partitions = part_buffer->GetPartitions(); + auto partition_key_map = part_buffer->GetReverseMap(); + + // ensure all partition directories are created before we start writing + g.CreatePartitionDirectories(context.client, op); + + for (idx_t i = 0; i < partitions.size(); i++) { + // get the partition write info for this buffer + auto &info = g.GetPartitionWriteInfo(context, op, partition_key_map[i]->values); + + auto local_copy_state = op.function.copy_to_initialize_local(context, *op.bind_data); + // push the chunks into the write state + for (auto &chunk : partitions[i]->Chunks()) { + op.function.copy_to_sink(context, *op.bind_data, *info.global_state, *local_copy_state, chunk); + } + op.function.copy_to_combine(context, *op.bind_data, *info.global_state, *local_copy_state); + local_copy_state.reset(); + partitions[i].reset(); + } + ResetAppendState(); + } }; unique_ptr PhysicalCopyToFile::CreateFileState(ClientContext &context, @@ -168640,10 +171440,7 @@ unique_ptr PhysicalCopyToFile::GetLocalSinkState(ExecutionContex auto state = make_uniq(nullptr); state->writer_offset = g.last_file_offset++; - state->part_buffer = - make_uniq(context.client, expected_types, partition_columns, g.partition_state); - state->part_buffer_append_state = make_uniq(); - state->part_buffer->InitializeAppendState(*state->part_buffer_append_state); + state->InitializeAppendState(context.client, *this, g); return std::move(state); } auto res = make_uniq(function.copy_to_initialize_local(context, *bind_data)); @@ -168719,7 +171516,7 @@ SinkResultType PhysicalCopyToFile::Sink(ExecutionContext &context, DataChunk &ch auto &l = input.local_state.Cast(); if (partition_output) { - l.part_buffer->Append(*l.part_buffer_append_state, chunk); + l.AppendToPartition(context, *this, g, chunk); return SinkResultType::NEED_MORE_INPUT; } @@ -168759,79 +171556,13 @@ SinkResultType PhysicalCopyToFile::Sink(ExecutionContext &context, DataChunk &ch return SinkResultType::NEED_MORE_INPUT; } -static void CreateDir(const string &dir_path, FileSystem &fs) { - if (!fs.DirectoryExists(dir_path)) { - fs.CreateDirectory(dir_path); - } -} - -static void CreateDirectories(const vector &cols, const vector &names, const vector &values, - string path, FileSystem &fs) { - CreateDir(path, fs); - - for (idx_t i = 0; i < cols.size(); i++) { - const auto &partition_col_name = names[cols[i]]; - const auto &partition_value = values[i]; - string p_dir = partition_col_name + "=" + partition_value.ToString(); - path = fs.JoinPath(path, p_dir); - CreateDir(path, fs); - } -} - -static string GetDirectory(const vector &cols, const vector &names, const vector &values, - string path, FileSystem &fs) { - for (idx_t i = 0; i < cols.size(); i++) { - const auto &partition_col_name = names[cols[i]]; - const auto &partition_value = values[i]; - string p_dir = partition_col_name + "=" + partition_value.ToString(); - path = fs.JoinPath(path, p_dir); - } - return path; -} - SinkCombineResultType PhysicalCopyToFile::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const { auto &g = input.global_state.Cast(); auto &l = input.local_state.Cast(); if (partition_output) { - auto &fs = FileSystem::GetFileSystem(context.client); - l.part_buffer->FlushAppendState(*l.part_buffer_append_state); - auto &partitions = l.part_buffer->GetPartitions(); - auto partition_key_map = l.part_buffer->GetReverseMap(); - - string trimmed_path = file_path; - StringUtil::RTrim(trimmed_path, fs.PathSeparator(trimmed_path)); - { - // create directories - auto lock = g.lock.GetExclusiveLock(); - lock_guard global_lock_on_partition_state(g.partition_state->lock); - const auto &global_partitions = g.partition_state->partitions; - // global_partitions have partitions added only at the back, so it's fine to only traverse the last part - - for (idx_t i = g.created_directories; i < global_partitions.size(); i++) { - CreateDirectories(partition_columns, names, global_partitions[i]->first.values, trimmed_path, fs); - } - g.created_directories = global_partitions.size(); - } - - for (idx_t i = 0; i < partitions.size(); i++) { - string hive_path = GetDirectory(partition_columns, names, partition_key_map[i]->values, trimmed_path, fs); - string full_path(filename_pattern.CreateFilename(fs, hive_path, file_extension, l.writer_offset)); - if (fs.FileExists(full_path) && !overwrite_or_ignore) { - throw IOException( - "failed to create %s, file exists! Enable OVERWRITE_OR_IGNORE option to force writing", full_path); - } - // Create a writer for the current file - auto fun_data_global = function.copy_to_initialize_global(context.client, *bind_data, full_path); - auto fun_data_local = function.copy_to_initialize_local(context, *bind_data); - - for (auto &chunk : partitions[i]->Chunks()) { - function.copy_to_sink(context, *bind_data, *fun_data_global, *fun_data_local, chunk); - } - - function.copy_to_combine(context, *bind_data, *fun_data_global, *fun_data_local); - function.copy_to_finalize(context.client, *bind_data, *fun_data_global); - } + // flush all remaining partitions + l.FlushPartitions(context, *this, g); } else if (function.copy_to_combine) { if (per_thread_output) { // For PER_THREAD_OUTPUT, we can combine/finalize immediately @@ -168852,7 +171583,12 @@ SinkCombineResultType PhysicalCopyToFile::Combine(ExecutionContext &context, Ope SinkFinalizeType PhysicalCopyToFile::Finalize(Pipeline &pipeline, Event &event, ClientContext &context, OperatorSinkFinalizeInput &input) const { auto &gstate = input.global_state.Cast(); - if (per_thread_output || partition_output) { + if (partition_output) { + // finalize any outstanding partitions + gstate.FinalizePartitions(context, *this); + return SinkFinalizeType::READY; + } + if (per_thread_output) { // already happened in combine return SinkFinalizeType::READY; } @@ -168989,6 +171725,7 @@ SinkResultType PhysicalDelete::Sink(ExecutionContext &context, DataChunk &chunk, lock_guard delete_guard(gstate.delete_lock); if (return_chunk) { + ustate.delete_chunk.Reset(); row_identifiers.Flatten(chunk.size()); table.Fetch(transaction, ustate.delete_chunk, column_ids, row_identifiers, chunk.size(), cfs); gstate.return_collection.Append(ustate.delete_chunk); @@ -169334,577 +172071,6 @@ vector> PhysicalExport::GetSources() const { } } // namespace duckdb -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/execution/operator/persistent/physical_fixed_batch_copy.hpp -// -// -//===----------------------------------------------------------------------===// - - - - - - - - - -namespace duckdb { - -class PhysicalFixedBatchCopy : public PhysicalOperator { -public: - static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::FIXED_BATCH_COPY_TO_FILE; - -public: - PhysicalFixedBatchCopy(vector types, CopyFunction function, unique_ptr bind_data, - idx_t estimated_cardinality); - - CopyFunction function; - unique_ptr bind_data; - string file_path; - bool use_tmp_file; - -public: - // Source interface - SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override; - - bool IsSource() const override { - return true; - } - -public: - // Sink interface - SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override; - SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override; - SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context, - OperatorSinkFinalizeInput &input) const override; - unique_ptr GetLocalSinkState(ExecutionContext &context) const override; - unique_ptr GetGlobalSinkState(ClientContext &context) const override; - SinkNextBatchType NextBatch(ExecutionContext &context, OperatorSinkNextBatchInput &input) const override; - - bool RequiresBatchIndex() const override { - return true; - } - - bool IsSink() const override { - return true; - } - - bool ParallelSink() const override { - return true; - } - -public: - void AddRawBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index, - unique_ptr collection) const; - void RepartitionBatches(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index, - bool final = false) const; - void FlushBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index) const; - bool ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p) const; - void ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p) const; - SinkFinalizeType FinalFlush(ClientContext &context, GlobalSinkState &gstate_p) const; -}; -} // namespace duckdb - - - - - - - - - -#include - -namespace duckdb { - -PhysicalFixedBatchCopy::PhysicalFixedBatchCopy(vector types, CopyFunction function_p, - unique_ptr bind_data_p, idx_t estimated_cardinality) - : PhysicalOperator(PhysicalOperatorType::BATCH_COPY_TO_FILE, std::move(types), estimated_cardinality), - function(std::move(function_p)), bind_data(std::move(bind_data_p)) { - if (!function.flush_batch || !function.prepare_batch || !function.desired_batch_size) { - throw InternalException("PhysicalFixedBatchCopy created for copy function that does not have " - "prepare_batch/flush_batch/desired_batch_size defined"); - } -} - -//===--------------------------------------------------------------------===// -// Sink -//===--------------------------------------------------------------------===// -class BatchCopyTask { -public: - virtual ~BatchCopyTask() { - } - - virtual void Execute(const PhysicalFixedBatchCopy &op, ClientContext &context, GlobalSinkState &gstate_p) = 0; -}; - -//===--------------------------------------------------------------------===// -// States -//===--------------------------------------------------------------------===// -class FixedBatchCopyGlobalState : public GlobalSinkState { -public: - explicit FixedBatchCopyGlobalState(unique_ptr global_state) - : rows_copied(0), global_state(std::move(global_state)), batch_size(0), scheduled_batch_index(0), - flushed_batch_index(0), any_flushing(false), any_finished(false) { - } - - mutex lock; - mutex flush_lock; - //! The total number of rows copied to the file - atomic rows_copied; - //! Global copy state - unique_ptr global_state; - //! The desired batch size (if any) - idx_t batch_size; - //! Unpartitioned batches - only used in case batch_size is required - map> raw_batches; - //! The prepared batch data by batch index - ready to flush - map> batch_data; - //! The index of the latest batch index that has been scheduled - atomic scheduled_batch_index; - //! The index of the latest batch index that has been flushed - atomic flushed_batch_index; - //! Whether or not any thread is flushing - atomic any_flushing; - //! Whether or not any threads are finished - atomic any_finished; - - void AddTask(unique_ptr task) { - lock_guard l(task_lock); - task_queue.push(std::move(task)); - } - - unique_ptr GetTask() { - lock_guard l(task_lock); - if (task_queue.empty()) { - return nullptr; - } - auto entry = std::move(task_queue.front()); - task_queue.pop(); - return entry; - } - - idx_t TaskCount() { - lock_guard l(task_lock); - return task_queue.size(); - } - - void AddBatchData(idx_t batch_index, unique_ptr new_batch) { - // move the batch data to the set of prepared batch data - lock_guard l(lock); - auto entry = batch_data.insert(make_pair(batch_index, std::move(new_batch))); - if (!entry.second) { - throw InternalException("Duplicate batch index %llu encountered in PhysicalFixedBatchCopy", batch_index); - } - } - -private: - mutex task_lock; - //! The task queue for the batch copy to file - queue> task_queue; -}; - -class FixedBatchCopyLocalState : public LocalSinkState { -public: - explicit FixedBatchCopyLocalState(unique_ptr local_state_p) - : local_state(std::move(local_state_p)), rows_copied(0) { - } - - //! Local copy state - unique_ptr local_state; - //! The current collection we are appending to - unique_ptr collection; - //! The append state of the collection - ColumnDataAppendState append_state; - //! How many rows have been copied in total - idx_t rows_copied; - //! The current batch index - optional_idx batch_index; - - void InitializeCollection(ClientContext &context, const PhysicalOperator &op) { - collection = make_uniq(BufferAllocator::Get(context), op.children[0]->types); - collection->InitializeAppend(append_state); - } -}; - -//===--------------------------------------------------------------------===// -// Sink -//===--------------------------------------------------------------------===// -SinkResultType PhysicalFixedBatchCopy::Sink(ExecutionContext &context, DataChunk &chunk, - OperatorSinkInput &input) const { - auto &state = input.local_state.Cast(); - if (!state.collection) { - state.InitializeCollection(context.client, *this); - state.batch_index = state.partition_info.batch_index.GetIndex(); - } - state.rows_copied += chunk.size(); - state.collection->Append(state.append_state, chunk); - return SinkResultType::NEED_MORE_INPUT; -} - -SinkCombineResultType PhysicalFixedBatchCopy::Combine(ExecutionContext &context, - OperatorSinkCombineInput &input) const { - auto &state = input.local_state.Cast(); - auto &gstate = input.global_state.Cast(); - gstate.rows_copied += state.rows_copied; - if (!gstate.any_finished) { - // signal that this thread is finished processing batches and that we should move on to Finalize - lock_guard l(gstate.lock); - gstate.any_finished = true; - } - ExecuteTasks(context.client, gstate); - - return SinkCombineResultType::FINISHED; -} - -//===--------------------------------------------------------------------===// -// ProcessRemainingBatchesEvent -//===--------------------------------------------------------------------===// -class ProcessRemainingBatchesTask : public ExecutorTask { -public: - ProcessRemainingBatchesTask(Executor &executor, shared_ptr event_p, FixedBatchCopyGlobalState &state_p, - ClientContext &context, const PhysicalFixedBatchCopy &op) - : ExecutorTask(executor), event(std::move(event_p)), op(op), gstate(state_p), context(context) { - } - - TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override { - while (op.ExecuteTask(context, gstate)) { - op.FlushBatchData(context, gstate, 0); - } - event->FinishTask(); - return TaskExecutionResult::TASK_FINISHED; - } - -private: - shared_ptr event; - const PhysicalFixedBatchCopy &op; - FixedBatchCopyGlobalState &gstate; - ClientContext &context; -}; - -class ProcessRemainingBatchesEvent : public BasePipelineEvent { -public: - ProcessRemainingBatchesEvent(const PhysicalFixedBatchCopy &op_p, FixedBatchCopyGlobalState &gstate_p, - Pipeline &pipeline_p, ClientContext &context) - : BasePipelineEvent(pipeline_p), op(op_p), gstate(gstate_p), context(context) { - } - const PhysicalFixedBatchCopy &op; - FixedBatchCopyGlobalState &gstate; - ClientContext &context; - -public: - void Schedule() override { - vector> tasks; - for (idx_t i = 0; i < idx_t(TaskScheduler::GetScheduler(context).NumberOfThreads()); i++) { - auto process_task = - make_uniq(pipeline->executor, shared_from_this(), gstate, context, op); - tasks.push_back(std::move(process_task)); - } - D_ASSERT(!tasks.empty()); - SetTasks(std::move(tasks)); - } - - void FinishEvent() override { - //! Now that all batches are processed we finish flushing the file to disk - op.FinalFlush(context, gstate); - } -}; -//===--------------------------------------------------------------------===// -// Finalize -//===--------------------------------------------------------------------===// -SinkFinalizeType PhysicalFixedBatchCopy::FinalFlush(ClientContext &context, GlobalSinkState &gstate_p) const { - auto &gstate = gstate_p.Cast(); - if (gstate.TaskCount() != 0) { - throw InternalException("Unexecuted tasks are remaining in PhysicalFixedBatchCopy::FinalFlush!?"); - } - idx_t min_batch_index = idx_t(NumericLimits::Maximum()); - FlushBatchData(context, gstate_p, min_batch_index); - if (gstate.scheduled_batch_index != gstate.flushed_batch_index) { - throw InternalException("Not all batches were flushed to disk - incomplete file?"); - } - if (function.copy_to_finalize) { - function.copy_to_finalize(context, *bind_data, *gstate.global_state); - - if (use_tmp_file) { - PhysicalCopyToFile::MoveTmpFile(context, file_path); - } - } - return SinkFinalizeType::READY; -} - -SinkFinalizeType PhysicalFixedBatchCopy::Finalize(Pipeline &pipeline, Event &event, ClientContext &context, - OperatorSinkFinalizeInput &input) const { - auto &gstate = input.global_state.Cast(); - idx_t min_batch_index = idx_t(NumericLimits::Maximum()); - // repartition any remaining batches - RepartitionBatches(context, input.global_state, min_batch_index, true); - // check if we have multiple tasks to execute - if (gstate.TaskCount() <= 1) { - // we don't - just execute the remaining task and finish flushing to disk - ExecuteTasks(context, input.global_state); - FinalFlush(context, input.global_state); - return SinkFinalizeType::READY; - } - // we have multiple tasks remaining - launch an event to execute the tasks in parallel - auto new_event = make_shared(*this, gstate, pipeline, context); - event.InsertEvent(std::move(new_event)); - return SinkFinalizeType::READY; -} - -//===--------------------------------------------------------------------===// -// Tasks -//===--------------------------------------------------------------------===// -class RepartitionedFlushTask : public BatchCopyTask { -public: - RepartitionedFlushTask() { - } - - void Execute(const PhysicalFixedBatchCopy &op, ClientContext &context, GlobalSinkState &gstate_p) override { - op.FlushBatchData(context, gstate_p, 0); - } -}; - -class PrepareBatchTask : public BatchCopyTask { -public: - PrepareBatchTask(idx_t batch_index, unique_ptr collection_p) - : batch_index(batch_index), collection(std::move(collection_p)) { - } - - idx_t batch_index; - unique_ptr collection; - - void Execute(const PhysicalFixedBatchCopy &op, ClientContext &context, GlobalSinkState &gstate_p) override { - auto &gstate = gstate_p.Cast(); - auto batch_data = - op.function.prepare_batch(context, *op.bind_data, *gstate.global_state, std::move(collection)); - gstate.AddBatchData(batch_index, std::move(batch_data)); - if (batch_index == gstate.flushed_batch_index) { - gstate.AddTask(make_uniq()); - } - } -}; - -//===--------------------------------------------------------------------===// -// Batch Data Handling -//===--------------------------------------------------------------------===// -void PhysicalFixedBatchCopy::AddRawBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index, - unique_ptr collection) const { - auto &gstate = gstate_p.Cast(); - - // add the batch index to the set of raw batches - lock_guard l(gstate.lock); - auto entry = gstate.raw_batches.insert(make_pair(batch_index, std::move(collection))); - if (!entry.second) { - throw InternalException("Duplicate batch index %llu encountered in PhysicalFixedBatchCopy", batch_index); - } -} - -static bool CorrectSizeForBatch(idx_t collection_size, idx_t desired_size) { - return idx_t(AbsValue(int64_t(collection_size) - int64_t(desired_size))) < STANDARD_VECTOR_SIZE; -} - -void PhysicalFixedBatchCopy::RepartitionBatches(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index, - bool final) const { - auto &gstate = gstate_p.Cast(); - - // repartition batches until the min index is reached - lock_guard l(gstate.lock); - if (gstate.raw_batches.empty()) { - return; - } - if (!final) { - if (gstate.any_finished) { - // we only repartition in ::NextBatch if all threads are still busy processing batches - // otherwise we might end up repartitioning a lot of data with only a few threads remaining - // which causes erratic performance - return; - } - // if this is not the final flush we first check if we have enough data to merge past the batch threshold - idx_t candidate_rows = 0; - for (auto entry = gstate.raw_batches.begin(); entry != gstate.raw_batches.end(); entry++) { - if (entry->first >= min_index) { - // we have exceeded the minimum batch - break; - } - candidate_rows += entry->second->Count(); - } - if (candidate_rows < gstate.batch_size) { - // not enough rows - cancel! - return; - } - } - // gather all collections we can repartition - idx_t max_batch_index = 0; - vector> collections; - for (auto entry = gstate.raw_batches.begin(); entry != gstate.raw_batches.end();) { - if (entry->first >= min_index) { - break; - } - max_batch_index = entry->first; - collections.push_back(std::move(entry->second)); - entry = gstate.raw_batches.erase(entry); - } - unique_ptr current_collection; - ColumnDataAppendState append_state; - // now perform the actual repartitioning - for (auto &collection : collections) { - if (!current_collection) { - if (CorrectSizeForBatch(collection->Count(), gstate.batch_size)) { - // the collection is ~approximately equal to the batch size (off by at most one vector) - // use it directly - gstate.AddTask(make_uniq(gstate.scheduled_batch_index++, std::move(collection))); - collection.reset(); - } else if (collection->Count() < gstate.batch_size) { - // the collection is smaller than the batch size - use it as a starting point - current_collection = std::move(collection); - collection.reset(); - } else { - // the collection is too large for a batch - we need to repartition - // create an empty collection - current_collection = make_uniq(BufferAllocator::Get(context), children[0]->types); - } - if (current_collection) { - current_collection->InitializeAppend(append_state); - } - } - if (!collection) { - // we have consumed the collection already - no need to append - continue; - } - // iterate the collection while appending - for (auto &chunk : collection->Chunks()) { - // append the chunk to the collection - current_collection->Append(append_state, chunk); - if (current_collection->Count() < gstate.batch_size) { - // the collection is still under the batch size - continue - continue; - } - // the collection is full - move it to the result and create a new one - gstate.AddTask(make_uniq(gstate.scheduled_batch_index++, std::move(current_collection))); - current_collection = make_uniq(BufferAllocator::Get(context), children[0]->types); - current_collection->InitializeAppend(append_state); - } - } - if (current_collection && current_collection->Count() > 0) { - // if there are any remaining batches that are not filled up to the batch size - // AND this is not the final collection - // re-add it to the set of raw (to-be-merged) batches - if (final || CorrectSizeForBatch(current_collection->Count(), gstate.batch_size)) { - gstate.AddTask(make_uniq(gstate.scheduled_batch_index++, std::move(current_collection))); - } else { - gstate.raw_batches[max_batch_index] = std::move(current_collection); - } - } -} - -void PhysicalFixedBatchCopy::FlushBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index) const { - auto &gstate = gstate_p.Cast(); - - // flush batch data to disk (if there are any to flush) - // grab the flush lock - we can only call flush_batch with this lock - // otherwise the data might end up in the wrong order - { - lock_guard l(gstate.flush_lock); - if (gstate.any_flushing) { - return; - } - gstate.any_flushing = true; - } - ActiveFlushGuard active_flush(gstate.any_flushing); - while (true) { - unique_ptr batch_data; - { - lock_guard l(gstate.lock); - if (gstate.batch_data.empty()) { - // no batch data left to flush - break; - } - auto entry = gstate.batch_data.begin(); - if (entry->first != gstate.flushed_batch_index) { - // this entry is not yet ready to be flushed - break; - } - if (entry->first < gstate.flushed_batch_index) { - throw InternalException("Batch index was out of order!?"); - } - batch_data = std::move(entry->second); - gstate.batch_data.erase(entry); - } - function.flush_batch(context, *bind_data, *gstate.global_state, *batch_data); - gstate.flushed_batch_index++; - } -} - -//===--------------------------------------------------------------------===// -// Tasks -//===--------------------------------------------------------------------===// -bool PhysicalFixedBatchCopy::ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p) const { - auto &gstate = gstate_p.Cast(); - auto task = gstate.GetTask(); - if (!task) { - return false; - } - task->Execute(*this, context, gstate_p); - return true; -} - -void PhysicalFixedBatchCopy::ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p) const { - while (ExecuteTask(context, gstate_p)) { - } -} - -//===--------------------------------------------------------------------===// -// Next Batch -//===--------------------------------------------------------------------===// -SinkNextBatchType PhysicalFixedBatchCopy::NextBatch(ExecutionContext &context, - OperatorSinkNextBatchInput &input) const { - auto &lstate = input.local_state; - auto &gstate_p = input.global_state; - auto &state = lstate.Cast(); - if (state.collection && state.collection->Count() > 0) { - // we finished processing this batch - // start flushing data - auto min_batch_index = lstate.partition_info.min_batch_index.GetIndex(); - // push the raw batch data into the set of unprocessed batches - AddRawBatchData(context.client, gstate_p, state.batch_index.GetIndex(), std::move(state.collection)); - // attempt to repartition to our desired batch size - RepartitionBatches(context.client, gstate_p, min_batch_index); - // execute a single batch task - ExecuteTask(context.client, gstate_p); - FlushBatchData(context.client, gstate_p, min_batch_index); - } - state.batch_index = lstate.partition_info.batch_index.GetIndex(); - - state.InitializeCollection(context.client, *this); - return SinkNextBatchType::READY; -} - -unique_ptr PhysicalFixedBatchCopy::GetLocalSinkState(ExecutionContext &context) const { - return make_uniq(function.copy_to_initialize_local(context, *bind_data)); -} - -unique_ptr PhysicalFixedBatchCopy::GetGlobalSinkState(ClientContext &context) const { - auto result = - make_uniq(function.copy_to_initialize_global(context, *bind_data, file_path)); - result->batch_size = function.desired_batch_size(context, *bind_data); - return std::move(result); -} - -//===--------------------------------------------------------------------===// -// Source -//===--------------------------------------------------------------------===// -SourceResultType PhysicalFixedBatchCopy::GetData(ExecutionContext &context, DataChunk &chunk, - OperatorSourceInput &input) const { - auto &g = sink_state->Cast(); - - chunk.SetCardinality(1); - chunk.SetValue(0, 0, Value::BIGINT(g.rows_copied)); - return SourceResultType::FINISHED; -} - -} // namespace duckdb @@ -170069,6 +172235,7 @@ void PhysicalInsert::ResolveDefaults(const TableCatalogEntry &table, DataChunk & } bool AllConflictsMeetCondition(DataChunk &result) { + result.Flatten(); auto data = FlatVector::GetData(result.data[0]); for (idx_t i = 0; i < result.size(); i++) { if (!data[i]) { @@ -170143,6 +172310,7 @@ static void CreateUpdateChunk(ExecutionContext &context, DataChunk &chunk, Table ExpressionExecutor where_executor(context.client, *do_update_condition); where_executor.Execute(chunk, do_update_filter_result); do_update_filter_result.SetCardinality(chunk.size()); + do_update_filter_result.Flatten(); ManagedSelection selection(chunk.size()); @@ -170338,14 +172506,13 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, DataChunk &chunk, gstate.initialized = true; } + if (return_chunk) { + gstate.return_collection.Append(lstate.insert_chunk); + } idx_t updated_tuples = OnConflictHandling(table, context, lstate); gstate.insert_count += lstate.insert_chunk.size(); gstate.insert_count += updated_tuples; storage.LocalAppend(gstate.append_state, table, context.client, lstate.insert_chunk, true); - - if (return_chunk) { - gstate.return_collection.Append(lstate.insert_chunk); - } } else { D_ASSERT(!return_chunk); // parallel append @@ -170402,8 +172569,8 @@ SinkCombineResultType PhysicalInsert::Combine(ExecutionContext &context, Operato storage.FinalizeLocalAppend(gstate.append_state); } else { // we have written rows to disk optimistically - merge directly into the transaction-local storage - gstate.table.GetStorage().FinalizeOptimisticWriter(context.client, *lstate.writer); gstate.table.GetStorage().LocalMerge(context.client, *lstate.local_collection); + gstate.table.GetStorage().FinalizeOptimisticWriter(context.client, *lstate.writer); } return SinkCombineResultType::FINISHED; @@ -170811,10 +172978,10 @@ class SelectNode : public QueryNode { namespace duckdb { struct PivotColumnEntry { - //! The set of values to match on + //! The set of values to match on (PIVOT only) vector values; - //! The star expression (UNPIVOT only) - unique_ptr star_expr; + //! The expression (UNPIVOT only) + unique_ptr expr; //! The alias of the pivot column entry string alias; @@ -170987,6 +173154,7 @@ PhysicalPivot::PhysicalPivot(vector types_p, unique_ptr(input.data[bound_pivot.group_count + aggr]); auto &pivot_value_child = ListVector::GetEntry(input.data[bound_pivot.group_count + aggr]); - if (list.offset != pivot_value_lists[r].offset || list.length != pivot_value_lists[r].length) { + if (list.length != pivot_value_lists[r].length) { throw InternalException("Pivot - unaligned lists between values and columns!?"); } - chunk.data[column_idx + aggr].SetValue(r, pivot_value_child.GetValue(list.offset + l)); + chunk.data[column_idx + aggr].SetValue(r, pivot_value_child.GetValue(pivot_value_lists[r].offset + l)); } } } @@ -173634,618 +175802,6 @@ class PhysicalDrop : public PhysicalOperator { -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/main/settings.hpp -// -// -//===----------------------------------------------------------------------===// - - - - - - -namespace duckdb { -class ClientContext; -class DatabaseInstance; -struct DBConfig; - -const string GetDefaultUserAgent(); - -struct AccessModeSetting { - static constexpr const char *Name = "access_mode"; - static constexpr const char *Description = "Access mode of the database (AUTOMATIC, READ_ONLY or READ_WRITE)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct AllowPersistentSecrets { - static constexpr const char *Name = "allow_persistent_secrets"; - static constexpr const char *Description = - "Allow the creation of persistent secrets, that are stored and loaded on restarts"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct CheckpointThresholdSetting { - static constexpr const char *Name = "checkpoint_threshold"; - static constexpr const char *Description = - "The WAL size threshold at which to automatically trigger a checkpoint (e.g. 1GB)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct DebugCheckpointAbort { - static constexpr const char *Name = "debug_checkpoint_abort"; - static constexpr const char *Description = - "DEBUG SETTING: trigger an abort while checkpointing for testing purposes"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct DebugForceExternal { - static constexpr const char *Name = "debug_force_external"; - static constexpr const char *Description = - "DEBUG SETTING: force out-of-core computation for operators that support it, used for testing"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct DebugForceNoCrossProduct { - static constexpr const char *Name = "debug_force_no_cross_product"; - static constexpr const char *Description = - "DEBUG SETTING: Force disable cross product generation when hyper graph isn't connected, used for testing"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct OrderedAggregateThreshold { - static constexpr const char *Name = "ordered_aggregate_threshold"; // NOLINT - static constexpr const char *Description = // NOLINT - "The number of rows to accumulate before sorting, used for tuning"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT; // NOLINT - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct DebugAsOfIEJoin { - static constexpr const char *Name = "debug_asof_iejoin"; // NOLINT - static constexpr const char *Description = "DEBUG SETTING: force use of IEJoin to implement AsOf joins"; // NOLINT - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; // NOLINT - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct PreferRangeJoins { - static constexpr const char *Name = "prefer_range_joins"; // NOLINT - static constexpr const char *Description = "Force use of range joins with mixed predicates"; // NOLINT - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; // NOLINT - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct DebugWindowMode { - static constexpr const char *Name = "debug_window_mode"; - static constexpr const char *Description = "DEBUG SETTING: switch window mode to use"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct DefaultCollationSetting { - static constexpr const char *Name = "default_collation"; - static constexpr const char *Description = "The collation setting used when none is specified"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct DefaultOrderSetting { - static constexpr const char *Name = "default_order"; - static constexpr const char *Description = "The order type used when none is specified (ASC or DESC)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct DefaultNullOrderSetting { - static constexpr const char *Name = "default_null_order"; - static constexpr const char *Description = "Null ordering used when none is specified (NULLS_FIRST or NULLS_LAST)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct DefaultSecretStorage { - static constexpr const char *Name = "default_secret_storage"; - static constexpr const char *Description = "Allows switching the default storage for secrets"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct DisabledFileSystemsSetting { - static constexpr const char *Name = "disabled_filesystems"; - static constexpr const char *Description = "Disable specific file systems preventing access (e.g. LocalFileSystem)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct DisabledOptimizersSetting { - static constexpr const char *Name = "disabled_optimizers"; - static constexpr const char *Description = "DEBUG SETTING: disable a specific set of optimizers (comma separated)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct EnableExternalAccessSetting { - static constexpr const char *Name = "enable_external_access"; - static constexpr const char *Description = - "Allow the database to access external state (through e.g. loading/installing modules, COPY TO/FROM, CSV " - "readers, pandas replacement scans, etc)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct EnableFSSTVectors { - static constexpr const char *Name = "enable_fsst_vectors"; - static constexpr const char *Description = - "Allow scans on FSST compressed segments to emit compressed vectors to utilize late decompression"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct AllowUnsignedExtensionsSetting { - static constexpr const char *Name = "allow_unsigned_extensions"; - static constexpr const char *Description = "Allow to load extensions with invalid or missing signatures"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct CustomExtensionRepository { - static constexpr const char *Name = "custom_extension_repository"; - static constexpr const char *Description = "Overrides the custom endpoint for remote extension installation"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct AutoloadExtensionRepository { - static constexpr const char *Name = "autoinstall_extension_repository"; - static constexpr const char *Description = - "Overrides the custom endpoint for extension installation on autoloading"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct AutoinstallKnownExtensions { - static constexpr const char *Name = "autoinstall_known_extensions"; - static constexpr const char *Description = - "Whether known extensions are allowed to be automatically installed when a query depends on them"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct AutoloadKnownExtensions { - static constexpr const char *Name = "autoload_known_extensions"; - static constexpr const char *Description = - "Whether known extensions are allowed to be automatically loaded when a query depends on them"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct EnableObjectCacheSetting { - static constexpr const char *Name = "enable_object_cache"; - static constexpr const char *Description = "Whether or not object cache is used to cache e.g. Parquet metadata"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct EnableHTTPMetadataCacheSetting { - static constexpr const char *Name = "enable_http_metadata_cache"; - static constexpr const char *Description = "Whether or not the global http metadata is used to cache HTTP metadata"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static Value GetSetting(ClientContext &context); -}; - -struct EnableProfilingSetting { - static constexpr const char *Name = "enable_profiling"; - static constexpr const char *Description = - "Enables profiling, and sets the output format (JSON, QUERY_TREE, QUERY_TREE_OPTIMIZER)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct EnableProgressBarSetting { - static constexpr const char *Name = "enable_progress_bar"; - static constexpr const char *Description = - "Enables the progress bar, printing progress to the terminal for long queries"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct EnableProgressBarPrintSetting { - static constexpr const char *Name = "enable_progress_bar_print"; - static constexpr const char *Description = - "Controls the printing of the progress bar, when 'enable_progress_bar' is true"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct ErrorsAsJsonSetting { - static constexpr const char *Name = "errors_as_json"; - static constexpr const char *Description = "Output error messages as structured JSON instead of as a raw string"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct ExplainOutputSetting { - static constexpr const char *Name = "explain_output"; - static constexpr const char *Description = "Output of EXPLAIN statements (ALL, OPTIMIZED_ONLY, PHYSICAL_ONLY)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct ExtensionDirectorySetting { - static constexpr const char *Name = "extension_directory"; - static constexpr const char *Description = "Set the directory to store extensions in"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct ExternalThreadsSetting { - static constexpr const char *Name = "external_threads"; - static constexpr const char *Description = "The number of external threads that work on DuckDB tasks."; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct FileSearchPathSetting { - static constexpr const char *Name = "file_search_path"; - static constexpr const char *Description = "A comma separated list of directories to search for input files"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct ForceCompressionSetting { - static constexpr const char *Name = "force_compression"; - static constexpr const char *Description = "DEBUG SETTING: forces a specific compression method to be used"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct ForceBitpackingModeSetting { - static constexpr const char *Name = "force_bitpacking_mode"; - static constexpr const char *Description = "DEBUG SETTING: forces a specific bitpacking mode"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct HomeDirectorySetting { - static constexpr const char *Name = "home_directory"; - static constexpr const char *Description = "Sets the home directory used by the system"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct IntegerDivisionSetting { - static constexpr const char *Name = "integer_division"; - static constexpr const char *Description = - "Whether or not the / operator defaults to integer division, or to floating point division"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct LogQueryPathSetting { - static constexpr const char *Name = "log_query_path"; - static constexpr const char *Description = - "Specifies the path to which queries should be logged (default: empty string, queries are not logged)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct LockConfigurationSetting { - static constexpr const char *Name = "lock_configuration"; - static constexpr const char *Description = "Whether or not the configuration can be altered"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct ImmediateTransactionModeSetting { - static constexpr const char *Name = "immediate_transaction_mode"; - static constexpr const char *Description = - "Whether transactions should be started lazily when needed, or immediately when BEGIN TRANSACTION is called"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct MaximumExpressionDepthSetting { - static constexpr const char *Name = "max_expression_depth"; - static constexpr const char *Description = - "The maximum expression depth limit in the parser. WARNING: increasing this setting and using very deep " - "expressions might lead to stack overflow errors."; - static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct MaximumMemorySetting { - static constexpr const char *Name = "max_memory"; - static constexpr const char *Description = "The maximum memory of the system (e.g. 1GB)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct OldImplicitCasting { - static constexpr const char *Name = "old_implicit_casting"; - static constexpr const char *Description = "Allow implicit casting to/from VARCHAR"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct PasswordSetting { - static constexpr const char *Name = "password"; - static constexpr const char *Description = "The password to use. Ignored for legacy compatibility."; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct PerfectHashThresholdSetting { - static constexpr const char *Name = "perfect_ht_threshold"; - static constexpr const char *Description = "Threshold in bytes for when to use a perfect hash table (default: 12)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct PivotFilterThreshold { - static constexpr const char *Name = "pivot_filter_threshold"; - static constexpr const char *Description = - "The threshold to switch from using filtered aggregates to LIST with a dedicated pivot operator"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct PivotLimitSetting { - static constexpr const char *Name = "pivot_limit"; - static constexpr const char *Description = - "The maximum number of pivot columns in a pivot statement (default: 100000)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct PreserveIdentifierCase { - static constexpr const char *Name = "preserve_identifier_case"; - static constexpr const char *Description = - "Whether or not to preserve the identifier case, instead of always lowercasing all non-quoted identifiers"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct PreserveInsertionOrder { - static constexpr const char *Name = "preserve_insertion_order"; - static constexpr const char *Description = - "Whether or not to preserve insertion order. If set to false the system is allowed to re-order any results " - "that do not contain ORDER BY clauses."; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct ExportLargeBufferArrow { - 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"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct ProfileOutputSetting { - static constexpr const char *Name = "profile_output"; - static constexpr const char *Description = - "The file to which profile output should be saved, or empty to print to the terminal"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct ProfilingModeSetting { - static constexpr const char *Name = "profiling_mode"; - static constexpr const char *Description = "The profiling mode (STANDARD or DETAILED)"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct ProgressBarTimeSetting { - static constexpr const char *Name = "progress_bar_time"; - static constexpr const char *Description = - "Sets the time (in milliseconds) how long a query needs to take before we start printing a progress bar"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct SchemaSetting { - static constexpr const char *Name = "schema"; - static constexpr const char *Description = - "Sets the default search schema. Equivalent to setting search_path to a single value."; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct SearchPathSetting { - static constexpr const char *Name = "search_path"; - static constexpr const char *Description = - "Sets the default catalog search path as a comma-separated list of values"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(ClientContext &context); -}; - -struct SecretDirectorySetting { - static constexpr const char *Name = "secret_directory"; - static constexpr const char *Description = "Set the directory to which persistent secrets are stored"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct TempDirectorySetting { - static constexpr const char *Name = "temp_directory"; - static constexpr const char *Description = "Set the directory to which to write temp files"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct ThreadsSetting { - static constexpr const char *Name = "threads"; - static constexpr const char *Description = "The number of total threads used by the system."; - static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct UsernameSetting { - static constexpr const char *Name = "username"; - static constexpr const char *Description = "The username to use. Ignored for legacy compatibility."; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct FlushAllocatorSetting { - static constexpr const char *Name = "allocator_flush_threshold"; - static constexpr const char *Description = - "Peak allocation threshold at which to flush the allocator after completing a task."; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct DuckDBApiSetting { - static constexpr const char *Name = "duckdb_api"; - static constexpr const char *Description = "DuckDB API surface"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -struct CustomUserAgentSetting { - static constexpr const char *Name = "custom_user_agent"; - static constexpr const char *Description = "Metadata from DuckDB callers"; - static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(ClientContext &context); -}; - -} // namespace duckdb namespace duckdb { @@ -174564,6 +176120,7 @@ class PhysicalRecursiveCTE : public PhysicalOperator { + namespace duckdb { PhysicalRecursiveCTE::PhysicalRecursiveCTE(string ctename, idx_t table_index, vector types, bool union_all, @@ -174727,6 +176284,16 @@ void PhysicalRecursiveCTE::ExecuteRecursivePipelines(ExecutionContext &context) //===--------------------------------------------------------------------===// // Pipeline Construction //===--------------------------------------------------------------------===// + +static void GatherColumnDataScans(const PhysicalOperator &op, vector> &delim_scans) { + if (op.type == PhysicalOperatorType::DELIM_SCAN || op.type == PhysicalOperatorType::CTE_SCAN) { + delim_scans.push_back(op); + } + for (auto &child : op.children) { + GatherColumnDataScans(*child, delim_scans); + } +} + void PhysicalRecursiveCTE::BuildPipelines(Pipeline ¤t, MetaPipeline &meta_pipeline) { op_state.reset(); sink_state.reset(); @@ -174746,6 +176313,20 @@ void PhysicalRecursiveCTE::BuildPipelines(Pipeline ¤t, MetaPipeline &meta_ recursive_meta_pipeline = make_shared(executor, state, this); recursive_meta_pipeline->SetRecursiveCTE(); recursive_meta_pipeline->Build(*children[1]); + + vector> ops; + GatherColumnDataScans(*children[1], ops); + + for (auto op : ops) { + auto entry = state.cte_dependencies.find(op); + if (entry == state.cte_dependencies.end()) { + continue; + } + // this chunk scan introduces a dependency to the current pipeline + // namely a dependency on the CTE pipeline to finish + auto cte_dependency = entry->second.get().shared_from_this(); + current.AddDependency(cte_dependency); + } } vector> PhysicalRecursiveCTE::GetSources() const { @@ -175064,13 +176645,13 @@ static void ReconstructGroupVectorTemplated(uint32_t group_values[], Value &min, auto min_data = min.GetValueUnsafe(); for (idx_t i = 0; i < entry_count; i++) { // extract the value of this group from the total group index - auto group_index = (group_values[i] >> shift) & mask; + auto group_index = UnsafeNumericCast((group_values[i] >> shift) & mask); if (group_index == 0) { // if it is 0, the value is NULL validity_mask.SetInvalid(i); } else { // otherwise we add the value (minus 1) to the min value - data[i] = min_data + group_index - 1; + data[i] = UnsafeNumericCast(min_data + group_index - 1); } } } @@ -175119,7 +176700,7 @@ void PerfectAggregateHashTable::Scan(idx_t &scan_position, DataChunk &result) { if (group_is_set[scan_position]) { // this group is set: add it to the set of groups to extract data_pointers[entry_count] = data + tuple_size * scan_position; - group_values[entry_count] = scan_position; + group_values[entry_count] = NumericCast(scan_position); entry_count++; if (entry_count == STANDARD_VECTOR_SIZE) { scan_position++; @@ -175607,7 +177188,7 @@ static uint32_t RequiredBitsForValue(uint32_t n) { n >>= 1; required_bits++; } - return required_bits; + return UnsafeNumericCast(required_bits); } template @@ -175717,7 +177298,7 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate range += 2; // figure out how many bits we need - idx_t required_bits = RequiredBitsForValue(range); + idx_t required_bits = RequiredBitsForValue(UnsafeNumericCast(range)); bits_per_group.push_back(required_bits); perfect_hash_bits += required_bits; // check if we have exceeded the bits for the hash @@ -176120,7 +177701,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi } // and when the build range is smaller than the threshold - auto &stats_build = *op.join_stats[0].get(); // lhs stats + auto &stats_build = *op.join_stats[1].get(); // rhs stats if (!NumericStats::HasMinMax(stats_build)) { return; } @@ -176135,7 +177716,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi } // Fill join_stats for invisible join - auto &stats_probe = *op.join_stats[1].get(); // rhs stats + auto &stats_probe = *op.join_stats[0].get(); // lhs stats if (!NumericStats::HasMinMax(stats_probe)) { return; } @@ -176295,7 +177876,6 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalCopyDataba - //===----------------------------------------------------------------------===// // DuckDB // @@ -176381,21 +177961,12 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalCopyToFile throw InternalException("BATCH_COPY_TO_FILE can only be used if batch indexes are supported"); } // batched copy to file - if (op.function.desired_batch_size) { - auto copy = make_uniq(op.types, op.function, std::move(op.bind_data), - op.estimated_cardinality); - copy->file_path = op.file_path; - copy->use_tmp_file = op.use_tmp_file; - copy->children.push_back(std::move(plan)); - return std::move(copy); - } else { - auto copy = make_uniq(op.types, op.function, std::move(op.bind_data), - op.estimated_cardinality); - copy->file_path = op.file_path; - copy->use_tmp_file = op.use_tmp_file; - copy->children.push_back(std::move(plan)); - return std::move(copy); - } + auto copy = make_uniq(op.types, op.function, std::move(op.bind_data), + op.estimated_cardinality); + copy->file_path = op.file_path; + copy->use_tmp_file = op.use_tmp_file; + copy->children.push_back(std::move(plan)); + return std::move(copy); } // COPY from select statement to file auto copy = make_uniq(op.types, op.function, std::move(op.bind_data), op.estimated_cardinality); @@ -177239,6 +178810,105 @@ class LogicalDistinct : public LogicalOperator { } // namespace duckdb +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp +// +// +//===----------------------------------------------------------------------===// + + + +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/optimizer/rule.hpp +// +// +//===----------------------------------------------------------------------===// + + + + +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/optimizer/matcher/logical_operator_matcher.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + +namespace duckdb { + +//! The LogicalOperatorMatcher class contains a set of matchers that can be used to match LogicalOperators +class LogicalOperatorMatcher { +public: + virtual ~LogicalOperatorMatcher() { + } + + virtual bool Match(LogicalOperatorType type) = 0; +}; + +//! The SpecificLogicalTypeMatcher class matches only a single specified LogicalOperatorType +class SpecificLogicalTypeMatcher : public LogicalOperatorMatcher { +public: + explicit SpecificLogicalTypeMatcher(LogicalOperatorType type) : type(type) { + } + + bool Match(LogicalOperatorType type) override { + return type == this->type; + } + +private: + LogicalOperatorType type; +}; + +} // namespace duckdb + + +namespace duckdb { +class ExpressionRewriter; + +class Rule { +public: + explicit Rule(ExpressionRewriter &rewriter) : rewriter(rewriter) { + } + virtual ~Rule() { + } + + //! The expression rewriter this rule belongs to + ExpressionRewriter &rewriter; + //! The expression matcher of the rule + unique_ptr root; + + ClientContext &GetContext() const; + virtual unique_ptr Apply(LogicalOperator &op, vector> &bindings, + bool &fixed_point, bool is_root) = 0; +}; + +} // namespace duckdb + + + +namespace duckdb { + +class OrderedAggregateOptimizer : public Rule { +public: + explicit OrderedAggregateOptimizer(ExpressionRewriter &rewriter); + + static unique_ptr Apply(ClientContext &context, BoundAggregateExpression &aggr, + vector> &groups, bool &changes_made); + unique_ptr Apply(LogicalOperator &op, vector> &bindings, bool &changes_made, + bool is_root) override; +}; + +} // namespace duckdb + namespace duckdb { @@ -177294,6 +178964,15 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalDistinct & auto first_aggregate = function_binder.BindAggregateFunction( FirstFun::GetFunction(logical_type), std::move(first_children), nullptr, AggregateType::NON_DISTINCT); first_aggregate->order_bys = op.order_by ? op.order_by->Copy() : nullptr; + + if (ClientConfig::GetConfig(context).enable_optimizer) { + bool changes_made = false; + auto new_expr = OrderedAggregateOptimizer::Apply(context, *first_aggregate, groups, changes_made); + if (new_expr) { + D_ASSERT(new_expr->type == ExpressionType::BOUND_AGGREGATE); + first_aggregate = unique_ptr_cast(std::move(new_expr)); + } + } // add the projection projections.push_back(make_uniq(logical_type, group_count + aggregates.size())); // push it to the list of aggregates @@ -177966,11 +179645,18 @@ static OrderPreservationType OrderPreservationRecursive(PhysicalOperator &op) { if (op.IsSource()) { return op.SourceOrder(); } + + idx_t child_idx = 0; for (auto &child : op.children) { + // Do not take the materialization phase of physical CTEs into account + if (op.type == PhysicalOperatorType::CTE && child_idx == 0) { + continue; + } auto child_preservation = OrderPreservationRecursive(*child); if (child_preservation != OrderPreservationType::INSERTION_ORDER) { return child_preservation; } + child_idx++; } return OrderPreservationType::INSERTION_ORDER; } @@ -178067,6 +179753,7 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalInsert &op + //===----------------------------------------------------------------------===// // DuckDB // @@ -178079,6 +179766,7 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalInsert &op + namespace duckdb { //! LogicalLimit represents a LIMIT clause @@ -178087,15 +179775,10 @@ class LogicalLimit : public LogicalOperator { static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_LIMIT; public: - LogicalLimit(int64_t limit_val, int64_t offset_val, unique_ptr limit, unique_ptr offset); + LogicalLimit(BoundLimitNode limit_val, BoundLimitNode offset_val); - //! Limit and offset values in case they are constants, used in optimizations. - int64_t limit_val; - int64_t offset_val; - //! The maximum amount of elements to emit - unique_ptr limit; - //! The offset from the start to begin emitting elements - unique_ptr offset; + BoundLimitNode limit_val; + BoundLimitNode offset_val; public: vector GetColumnBindings() override; @@ -178112,27 +179795,58 @@ class LogicalLimit : public LogicalOperator { namespace duckdb { +bool UseBatchLimit(BoundLimitNode &limit_val, BoundLimitNode &offset_val) { +#ifdef DUCKDB_ALTERNATIVE_VERIFY + return true; +#else + // we only use batch limit when we are computing a small amount of values + // as the batch limit materializes this many rows PER thread + static constexpr const idx_t BATCH_LIMIT_THRESHOLD = 10000; + + if (limit_val.Type() != LimitNodeType::CONSTANT_VALUE) { + return false; + } + if (offset_val.Type() == LimitNodeType::EXPRESSION_VALUE) { + return false; + } + idx_t total_offset = limit_val.GetConstantValue(); + if (offset_val.Type() == LimitNodeType::CONSTANT_VALUE) { + total_offset += offset_val.GetConstantValue(); + } + return total_offset <= BATCH_LIMIT_THRESHOLD; +#endif +} + unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalLimit &op) { D_ASSERT(op.children.size() == 1); auto plan = CreatePlan(*op.children[0]); unique_ptr limit; - if (!PreserveInsertionOrder(*plan)) { - // use parallel streaming limit if insertion order is not important - limit = make_uniq(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit), - std::move(op.offset), op.estimated_cardinality, true); - } else { - // maintaining insertion order is important - if (UseBatchIndex(*plan)) { - // source supports batch index: use parallel batch limit - limit = make_uniq(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit), - std::move(op.offset), op.estimated_cardinality); + switch (op.limit_val.Type()) { + case LimitNodeType::EXPRESSION_PERCENTAGE: + case LimitNodeType::CONSTANT_PERCENTAGE: + limit = make_uniq(op.types, std::move(op.limit_val), std::move(op.offset_val), + op.estimated_cardinality); + break; + default: + if (!PreserveInsertionOrder(*plan)) { + // use parallel streaming limit if insertion order is not important + limit = make_uniq(op.types, std::move(op.limit_val), std::move(op.offset_val), + op.estimated_cardinality, true); } else { - // source does not support batch index: use a non-parallel streaming limit - limit = make_uniq(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit), - std::move(op.offset), op.estimated_cardinality, false); + // maintaining insertion order is important + if (UseBatchIndex(*plan) && UseBatchLimit(op.limit_val, op.offset_val)) { + // source supports batch index: use parallel batch limit + limit = make_uniq(op.types, std::move(op.limit_val), std::move(op.offset_val), + op.estimated_cardinality); + } else { + // source does not support batch index: use a non-parallel streaming limit + limit = make_uniq(op.types, std::move(op.limit_val), std::move(op.offset_val), + op.estimated_cardinality, false); + } } + break; } limit->children.push_back(std::move(plan)); @@ -178142,24 +179856,6 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalLimit &op) } // namespace duckdb - - -namespace duckdb { - -unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalLimitPercent &op) { - D_ASSERT(op.children.size() == 1); - - auto plan = CreatePlan(*op.children[0]); - - auto limit = make_uniq(op.types, op.limit_percent, op.offset_val, std::move(op.limit), - std::move(op.offset), op.estimated_cardinality); - limit->children.push_back(std::move(plan)); - return std::move(limit); -} - -} // namespace duckdb - - //===----------------------------------------------------------------------===// // DuckDB // @@ -179593,9 +181289,6 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalOperator & case LogicalOperatorType::LOGICAL_LIMIT: plan = CreatePlan(op.Cast()); break; - case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: - plan = CreatePlan(op.Cast()); - break; case LogicalOperatorType::LOGICAL_SAMPLE: plan = CreatePlan(op.Cast()); break; @@ -179730,6 +181423,10 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalOperator & } plan->estimated_cardinality = op.estimated_cardinality; +#ifdef DUCKDB_VERIFY_VECTOR_OPERATOR + auto verify = make_uniq(std::move(plan)); + plan = std::move(verify); +#endif return plan; } @@ -180026,10 +181723,9 @@ idx_t RadixHTConfig::ExternalRadixBits(const idx_t &maximum_sink_radix_bits_p) { idx_t RadixHTConfig::SinkCapacity(ClientContext &context) { // Get active and maximum number of threads const idx_t active_threads = TaskScheduler::GetScheduler(context).NumberOfThreads(); - const auto max_threads = DBConfig::GetConfig(context).options.maximum_threads; // Compute cache size per active thread (assuming cache is shared) - const auto total_shared_cache_size = max_threads * L3_CACHE_SIZE; + const auto total_shared_cache_size = active_threads * L3_CACHE_SIZE; const auto cache_per_active_thread = L1_CACHE_SIZE + L2_CACHE_SIZE + total_shared_cache_size / active_threads; // Divide cache per active thread by entry size, round up to next power of two, to get capacity @@ -180085,7 +181781,8 @@ void RadixPartitionedHashTable::PopulateGroupChunk(DataChunk &group_chunk, DataC group_chunk.Verify(); } -bool MaybeRepartition(ClientContext &context, RadixHTGlobalSinkState &gstate, RadixHTLocalSinkState &lstate) { +bool MaybeRepartition(ClientContext &context, RadixHTGlobalSinkState &gstate, RadixHTLocalSinkState &lstate, + const idx_t &active_threads) { auto &config = gstate.config; auto &ht = *lstate.ht; auto &partitioned_data = ht.GetPartitionedData(); @@ -180093,19 +181790,19 @@ bool MaybeRepartition(ClientContext &context, RadixHTGlobalSinkState &gstate, Ra // Check if we're approaching the memory limit auto &temporary_memory_state = *gstate.temporary_memory_state; const auto total_size = partitioned_data->SizeInBytes() + ht.Capacity() * sizeof(aggr_ht_entry_t); - idx_t thread_limit = temporary_memory_state.GetReservation() / gstate.active_threads; + idx_t thread_limit = temporary_memory_state.GetReservation() / active_threads; if (total_size > thread_limit) { // We're over the thread memory limit if (!gstate.external) { // We haven't yet triggered out-of-core behavior, but maybe we don't have to, grab the lock and check again lock_guard guard(gstate.lock); - thread_limit = temporary_memory_state.GetReservation() / gstate.active_threads; + thread_limit = temporary_memory_state.GetReservation() / active_threads; if (total_size > thread_limit) { // Out-of-core would be triggered below, try to increase the reservation auto remaining_size = - MaxValue(gstate.active_threads * total_size, temporary_memory_state.GetRemainingSize()); + MaxValue(active_threads * total_size, temporary_memory_state.GetRemainingSize()); temporary_memory_state.SetRemainingSize(context, 2 * remaining_size); - thread_limit = temporary_memory_state.GetReservation() / gstate.active_threads; + thread_limit = temporary_memory_state.GetReservation() / active_threads; } } } @@ -180128,7 +181825,7 @@ bool MaybeRepartition(ClientContext &context, RadixHTGlobalSinkState &gstate, Ra } // We can go external when there is only one active thread, but we shouldn't repartition here - if (gstate.active_threads < 2) { + if (active_threads < 2) { return false; } @@ -180176,7 +181873,8 @@ void RadixPartitionedHashTable::Sink(ExecutionContext &context, DataChunk &chunk return; // We can fit another chunk } - if (gstate.active_threads > 2) { + const idx_t active_threads = gstate.active_threads; + if (active_threads > 2) { // 'Reset' the HT without taking its data, we can just keep appending to the same collection // This only works because we never resize the HT ht.ClearPointerTable(); @@ -180185,7 +181883,7 @@ void RadixPartitionedHashTable::Sink(ExecutionContext &context, DataChunk &chunk } // Check if we need to repartition - auto repartitioned = MaybeRepartition(context.client, gstate, lstate); + auto repartitioned = MaybeRepartition(context.client, gstate, lstate, active_threads); if (repartitioned && ht.Count() != 0) { // We repartitioned, but we didn't clear the pointer table / reset the count because we're on 1 or 2 threads @@ -180206,7 +181904,7 @@ void RadixPartitionedHashTable::Combine(ExecutionContext &context, GlobalSinkSta // Set any_combined, then check one last time whether we need to repartition gstate.any_combined = true; - MaybeRepartition(context.client, gstate, lstate); + MaybeRepartition(context.client, gstate, lstate, gstate.active_threads); auto &ht = *lstate.ht; ht.UnpinData(); @@ -180316,7 +182014,7 @@ class RadixHTGlobalSourceState : public GlobalSourceState { //! For synchronizing scan tasks mutex lock; idx_t scan_idx; - idx_t scan_done; + atomic scan_done; }; enum class RadixHTScanStatus : uint8_t { INIT, IN_PROGRESS, DONE }; @@ -181203,19 +182901,24 @@ static idx_t FindTypedRangeBound(const WindowInputColumn &over, const idx_t orde WindowColumnIterator begin(over, order_begin); WindowColumnIterator end(over, order_end); - if (order_begin < prev.start && prev.start < order_end) { - const auto first = over.GetCell(prev.start); - if (!comp(val, first)) { - // prev.first <= val, so we can start further forward - begin += (prev.start - order_begin); + // Try to reuse the previous bounds to restrict the search. + // This is only valid if the previous bounds were non-empty + // Only inject the comparisons if the previous bounds are a strict subset. + if (prev.start < prev.end) { + if (order_begin < prev.start && prev.start < order_end) { + const auto first = over.GetCell(prev.start); + if (!comp(val, first)) { + // prev.first <= val, so we can start further forward + begin += (prev.start - order_begin); + } } - } - if (order_begin <= prev.end && prev.end < order_end) { - const auto second = over.GetCell(prev.end); - if (!comp(second, val)) { - // val <= prev.second, so we can end further back - // (prev.second is the largest peer) - end -= (order_end - prev.end - 1); + if (order_begin < prev.end && prev.end < order_end) { + const auto second = over.GetCell(prev.end - 1); + if (!comp(second, val)) { + // val <= prev.second, so we can end further back + // (prev.second is the largest peer) + end -= (order_end - prev.end - 1); + } } } @@ -181936,77 +183639,81 @@ void WindowAggregateExecutor::Sink(DataChunk &input_chunk, const idx_t input_idx WindowExecutor::Sink(input_chunk, input_idx, total_count); } -void WindowAggregateExecutor::Finalize() { - D_ASSERT(aggregator); - - // Estimate the frame statistics - // Default to the entire partition if we don't know anything - FrameStats stats; - const int64_t count = aggregator->GetInputs().size(); +static void ApplyWindowStats(const WindowBoundary &boundary, FrameDelta &delta, BaseStatistics *base, bool is_start) { + // Avoid overflow by clamping to the frame bounds + auto base_stats = delta; - // First entry is the frame start - stats[0] = FrameDelta(-count, count); - auto base = wexpr.expr_stats.empty() ? nullptr : wexpr.expr_stats[0].get(); - switch (wexpr.start) { + switch (boundary) { case WindowBoundary::UNBOUNDED_PRECEDING: - stats[0].end = 0; + if (is_start) { + delta.end = 0; + return; + } break; - case WindowBoundary::CURRENT_ROW_ROWS: - stats[0].begin = stats[0].end = 0; + case WindowBoundary::UNBOUNDED_FOLLOWING: + if (!is_start) { + delta.begin = 0; + return; + } break; + case WindowBoundary::CURRENT_ROW_ROWS: + delta.begin = delta.end = 0; + return; case WindowBoundary::EXPR_PRECEDING_ROWS: if (base && base->GetStatsType() == StatisticsType::NUMERIC_STATS && NumericStats::HasMinMax(*base)) { // Preceding so negative offset from current row - stats[0].begin = -NumericStats::GetMax(*base); - stats[0].end = -NumericStats::GetMin(*base) + 1; + base_stats.begin = NumericStats::GetMin(*base); + base_stats.end = NumericStats::GetMax(*base); + if (delta.begin < base_stats.end && base_stats.end < delta.end) { + delta.begin = -base_stats.end; + } + if (delta.begin < base_stats.begin && base_stats.begin < delta.end) { + delta.end = -base_stats.begin + 1; + } } - break; + return; case WindowBoundary::EXPR_FOLLOWING_ROWS: if (base && base->GetStatsType() == StatisticsType::NUMERIC_STATS && NumericStats::HasMinMax(*base)) { - stats[0].begin = NumericStats::GetMin(*base); - stats[0].end = NumericStats::GetMax(*base) + 1; + base_stats.begin = NumericStats::GetMin(*base); + base_stats.end = NumericStats::GetMax(*base); + if (base_stats.end < delta.end) { + delta.end = base_stats.end + 1; + } } - break; + return; case WindowBoundary::CURRENT_ROW_RANGE: case WindowBoundary::EXPR_PRECEDING_RANGE: case WindowBoundary::EXPR_FOLLOWING_RANGE: - break; + return; default: + break; + } + + if (is_start) { throw InternalException("Unsupported window start boundary"); + } else { + throw InternalException("Unsupported window end boundary"); } +} + +void WindowAggregateExecutor::Finalize() { + D_ASSERT(aggregator); + + // Estimate the frame statistics + // Default to the entire partition if we don't know anything + FrameStats stats; + const int64_t count = aggregator->GetInputs().size(); + + // First entry is the frame start + stats[0] = FrameDelta(-count, count); + auto base = wexpr.expr_stats.empty() ? nullptr : wexpr.expr_stats[0].get(); + ApplyWindowStats(wexpr.start, stats[0], base, true); // Second entry is the frame end stats[1] = FrameDelta(-count, count); base = wexpr.expr_stats.empty() ? nullptr : wexpr.expr_stats[1].get(); - switch (wexpr.end) { - case WindowBoundary::UNBOUNDED_FOLLOWING: - stats[1].begin = 0; - break; - case WindowBoundary::CURRENT_ROW_ROWS: - stats[1].begin = stats[1].end = 0; - break; - case WindowBoundary::EXPR_PRECEDING_ROWS: - if (base && base->GetStatsType() == StatisticsType::NUMERIC_STATS && NumericStats::HasMinMax(*base)) { - // Preceding so negative offset from current row - stats[1].begin = -NumericStats::GetMax(*base); - stats[1].end = -NumericStats::GetMin(*base) + 1; - } - break; - case WindowBoundary::EXPR_FOLLOWING_ROWS: - if (base && base->GetStatsType() == StatisticsType::NUMERIC_STATS && NumericStats::HasMinMax(*base)) { - stats[1].begin = NumericStats::GetMin(*base); - stats[1].end = NumericStats::GetMax(*base) + 1; - } - break; - - case WindowBoundary::CURRENT_ROW_RANGE: - case WindowBoundary::EXPR_PRECEDING_RANGE: - case WindowBoundary::EXPR_FOLLOWING_RANGE: - break; - default: - throw InternalException("Unsupported window end boundary"); - } + ApplyWindowStats(wexpr.end, stats[1], base, false); aggregator->Finalize(stats); } @@ -182278,6 +183985,7 @@ void WindowValueExecutor::Sink(DataChunk &input_chunk, const idx_t input_idx, co if (check_nulls) { const auto count = input_chunk.size(); + payload_chunk.Flatten(); UnifiedVectorFormat vdata; payload_chunk.data[0].ToUnifiedFormat(count, vdata); if (!vdata.validity.AllValid()) { @@ -183067,7 +184775,7 @@ size_t WindowNaiveState::Hash(idx_t rid) { auto &inputs = const_cast(gstate.GetInputs()); leaves.Reference(inputs); - sel_t s = rid; + auto s = UnsafeNumericCast(rid); SelectionVector sel(&s); leaves.Slice(sel, 1); leaves.Hash(hashes); @@ -183078,10 +184786,10 @@ size_t WindowNaiveState::Hash(idx_t rid) { bool WindowNaiveState::KeyEqual(const idx_t &lhs, const idx_t &rhs) { auto &inputs = const_cast(gstate.GetInputs()); - sel_t l = lhs; + auto l = UnsafeNumericCast(lhs); SelectionVector lsel(&l); - sel_t r = rhs; + auto r = UnsafeNumericCast(rhs); SelectionVector rsel(&r); sel_t f = 0; @@ -183123,7 +184831,7 @@ void WindowNaiveState::Evaluate(const DataChunk &bounds, Vector &result, idx_t c } pdata[flush_count] = agg_state; - update_sel[flush_count++] = f; + update_sel[flush_count++] = UnsafeNumericCast(f); if (flush_count >= STANDARD_VECTOR_SIZE) { FlushStates(); } @@ -183174,7 +184882,7 @@ void WindowSegmentTree::Finalize(const FrameStats &stats) { } WindowSegmentTree::~WindowSegmentTree() { - if (!aggr.function.destructor) { + if (!aggr.function.destructor || !gstate) { // nothing to destroy return; } @@ -183891,7 +185599,7 @@ WindowDistinctAggregator::DistinctSortTree::DistinctSortTree(ZippedElements &&pr if (prev_idx < i + 1) { updates[nupdate] = curr_state; // input_idx - sel[nupdate] = std::get<1>(zipped_level[j]); + sel[nupdate] = UnsafeNumericCast(std::get<1>(zipped_level[j])); ++nupdate; } @@ -184407,7 +186115,7 @@ struct FirstFunctionString : public FirstFunctionBase { auto ptr = LAST ? new char[len] : char_ptr_cast(input_data.allocator.Allocate(len)); memcpy(ptr, value.GetData(), len); - state.value = string_t(ptr, len); + state.value = string_t(ptr, UnsafeNumericCast(len)); } } } @@ -184476,7 +186184,7 @@ struct FirstVectorFunction { state.value = new Vector(input.GetType()); state.value->SetVectorType(VectorType::CONSTANT_VECTOR); } - sel_t selv = idx; + sel_t selv = UnsafeNumericCast(idx); SelectionVector sel(&selv); VectorOperations::Copy(input, *state.value, sel, 1, 0, 0); } @@ -184705,6 +186413,7 @@ void BuiltinFunctions::RegisterDistributiveAggregates() { + namespace duckdb { struct SortedAggregateBindData : public FunctionData { @@ -185215,7 +186924,7 @@ struct SortedAggregateFunction { order_state->sel.Initialize(sel_data.data() + order_state->offset); start += order_state->nsel; } - sel_data[order_state->offset++] = sidx; + sel_data[order_state->offset++] = UnsafeNumericCast(sidx); } // Append nonempty slices to the arguments @@ -185299,7 +187008,7 @@ struct SortedAggregateFunction { if (unsorted_count < order_bind.threshold) { auto state = sdata[finalized]; prefixed.Reset(); - prefixed.data[0].Reference(Value::USMALLINT(finalized)); + prefixed.data[0].Reference(Value::USMALLINT(UnsafeNumericCast(finalized))); state->Finalize(order_bind, prefixed, *local_sort); unsorted_count += state_unprocessed[finalized]; @@ -185728,7 +187437,7 @@ static bool ArrayToArrayCast(Vector &source, Vector &result, idx_t count, CastPa // Cant cast between arrays of different sizes auto msg = StringUtil::Format("Cannot cast array of size %u to array of size %u", source_array_size, target_array_size); - HandleCastError::AssignError(msg, parameters.error_message); + HandleCastError::AssignError(msg, parameters); if (!parameters.strict) { // if this was a TRY_CAST, we know every row will fail, so just return null result.SetVectorType(VectorType::CONSTANT_VECTOR); @@ -185851,9 +187560,7 @@ static bool ArrayToListCast(Vector &source, Vector &result, idx_t count, CastPar // FIXME: dont flatten source.Flatten(count); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } + auto array_size = ArrayType::GetSize(source.GetType()); auto child_count = count * array_size; @@ -185937,12 +187644,20 @@ BoundCastInfo DefaultCasts::ArrayCastSwitch(BindCastInput &input, const LogicalT namespace duckdb { +struct VectorTryCastData { + VectorTryCastData(Vector &result_p, CastParameters ¶meters) : result(result_p), parameters(parameters) { + } + + Vector &result; + CastParameters ¶meters; + bool all_converted = true; +}; + struct HandleVectorCastError { template - static RESULT_TYPE Operation(string error_message, ValidityMask &mask, idx_t idx, string *error_message_ptr, - bool &all_converted) { - HandleCastError::AssignError(error_message, error_message_ptr); - all_converted = false; + static RESULT_TYPE Operation(string error_message, ValidityMask &mask, idx_t idx, VectorTryCastData &cast_data) { + HandleCastError::AssignError(error_message, cast_data.parameters); + cast_data.all_converted = false; mask.SetInvalid(idx); return NullValue(); } @@ -185965,17 +187680,6 @@ struct VectorStringCastOperator { } }; -struct VectorTryCastData { - VectorTryCastData(Vector &result_p, string *error_message_p, bool strict_p) - : result(result_p), error_message(error_message_p), strict(strict_p) { - } - - Vector &result; - string *error_message; - bool strict; - bool all_converted = true; -}; - template struct VectorTryCastOperator { template @@ -185986,7 +187690,7 @@ struct VectorTryCastOperator { } auto data = (VectorTryCastData *)dataptr; return HandleVectorCastError::Operation(CastExceptionText(input), mask, - idx, data->error_message, data->all_converted); + idx, *data); } }; @@ -185996,11 +187700,11 @@ struct VectorTryCastStrictOperator { static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) { auto data = (VectorTryCastData *)dataptr; RESULT_TYPE output; - if (DUCKDB_LIKELY(OP::template Operation(input, output, data->strict))) { + if (DUCKDB_LIKELY(OP::template Operation(input, output, data->parameters.strict))) { return output; } return HandleVectorCastError::Operation(CastExceptionText(input), mask, - idx, data->error_message, data->all_converted); + idx, *data); } }; @@ -186010,14 +187714,13 @@ struct VectorTryCastErrorOperator { static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) { auto data = (VectorTryCastData *)dataptr; RESULT_TYPE output; - if (DUCKDB_LIKELY( - OP::template Operation(input, output, data->error_message, data->strict))) { + if (DUCKDB_LIKELY(OP::template Operation(input, output, data->parameters))) { return output; } - bool has_error = data->error_message && !data->error_message->empty(); + bool has_error = data->parameters.error_message && !data->parameters.error_message->empty(); return HandleVectorCastError::Operation( - has_error ? *data->error_message : CastExceptionText(input), mask, idx, - data->error_message, data->all_converted); + has_error ? *data->parameters.error_message : CastExceptionText(input), mask, idx, + *data); } }; @@ -186027,24 +187730,23 @@ struct VectorTryCastStringOperator { static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) { auto data = (VectorTryCastData *)dataptr; RESULT_TYPE output; - if (DUCKDB_LIKELY(OP::template Operation(input, output, data->result, - data->error_message, data->strict))) { + if (DUCKDB_LIKELY( + OP::template Operation(input, output, data->result, data->parameters))) { return output; } return HandleVectorCastError::Operation(CastExceptionText(input), mask, - idx, data->error_message, data->all_converted); + idx, *data); } }; struct VectorDecimalCastData { - VectorDecimalCastData(string *error_message_p, uint8_t width_p, uint8_t scale_p) - : error_message(error_message_p), width(width_p), scale(scale_p) { + VectorDecimalCastData(Vector &result, CastParameters ¶meters, uint8_t width_p, uint8_t scale_p) + : vector_cast_data(result, parameters), width(width_p), scale(scale_p) { } - string *error_message; + VectorTryCastData vector_cast_data; uint8_t width; uint8_t scale; - bool all_converted = true; }; template @@ -186053,10 +187755,10 @@ struct VectorDecimalCastOperator { static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) { auto data = (VectorDecimalCastData *)dataptr; RESULT_TYPE result_value; - if (!OP::template Operation(input, result_value, data->error_message, data->width, - data->scale)) { + if (!OP::template Operation(input, result_value, data->vector_cast_data.parameters, + data->width, data->scale)) { return HandleVectorCastError::Operation("Failed to cast decimal value", mask, idx, - data->error_message, data->all_converted); + data->vector_cast_data); } return result_value; } @@ -186071,7 +187773,7 @@ struct VectorCastHelpers { template static bool TemplatedTryCastLoop(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { - VectorTryCastData input(result, parameters.error_message, parameters.strict); + VectorTryCastData input(result, parameters); UnaryExecutor::GenericExecute(source, result, count, &input, parameters.error_message); return input.all_converted; } @@ -186105,12 +187807,12 @@ struct VectorCastHelpers { } template - static bool TemplatedDecimalCast(Vector &source, Vector &result, idx_t count, string *error_message, uint8_t width, - uint8_t scale) { - VectorDecimalCastData input(error_message, width, scale); + static bool TemplatedDecimalCast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters, + uint8_t width, uint8_t scale) { + VectorDecimalCastData input(result, parameters, width, scale); UnaryExecutor::GenericExecute>(source, result, count, (void *)&input, - error_message); - return input.all_converted; + parameters.error_message); + return input.vector_cast_data.all_converted; } template @@ -186120,17 +187822,14 @@ struct VectorCastHelpers { auto scale = DecimalType::GetScale(result_type); switch (result_type.InternalType()) { case PhysicalType::INT16: - return TemplatedDecimalCast(source, result, count, parameters.error_message, - width, scale); + return TemplatedDecimalCast(source, result, count, parameters, width, scale); case PhysicalType::INT32: - return TemplatedDecimalCast(source, result, count, parameters.error_message, - width, scale); + return TemplatedDecimalCast(source, result, count, parameters, width, scale); case PhysicalType::INT64: - return TemplatedDecimalCast(source, result, count, parameters.error_message, - width, scale); + return TemplatedDecimalCast(source, result, count, parameters, width, scale); case PhysicalType::INT128: - return TemplatedDecimalCast(source, result, count, parameters.error_message, - width, scale); + return TemplatedDecimalCast(source, result, count, parameters, width, + scale); default: throw InternalException("Unimplemented internal type for decimal"); } @@ -186178,31 +187877,31 @@ BoundCastInfo DefaultCasts::BitCastSwitch(BindCastInput &input, const LogicalTyp switch (target.id()) { // Numerics case LogicalTypeId::BOOLEAN: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::TINYINT: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::SMALLINT: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::INTEGER: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::BIGINT: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::UTINYINT: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::USMALLINT: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::UINTEGER: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::UBIGINT: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::HUGEINT: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::UHUGEINT: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::FLOAT: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::DOUBLE: - return BoundCastInfo(&VectorCastHelpers::TryCastLoop); + return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop); case LogicalTypeId::BLOB: return BoundCastInfo(&VectorCastHelpers::StringCast); @@ -186306,6 +188005,7 @@ BindCastInput::BindCastInput(CastFunctionSet &function_set, optional_ptr 0; i--) { auto &bind_function = bind_functions[i - 1]; BindCastInput input(*this, bind_function.info.get(), get_input.context); + input.query_location = get_input.query_location; auto result = bind_function.function(input, source, target); if (result.function) { // found a cast function! return it @@ -186511,17 +188212,17 @@ static bool FromDecimalCast(Vector &source, Vector &result, idx_t count, CastPar auto scale = DecimalType::GetScale(source_type); switch (source_type.InternalType()) { case PhysicalType::INT16: - return VectorCastHelpers::TemplatedDecimalCast( - source, result, count, parameters.error_message, width, scale); + return VectorCastHelpers::TemplatedDecimalCast(source, result, count, + parameters, width, scale); case PhysicalType::INT32: - return VectorCastHelpers::TemplatedDecimalCast( - source, result, count, parameters.error_message, width, scale); + return VectorCastHelpers::TemplatedDecimalCast(source, result, count, + parameters, width, scale); case PhysicalType::INT64: - return VectorCastHelpers::TemplatedDecimalCast( - source, result, count, parameters.error_message, width, scale); + return VectorCastHelpers::TemplatedDecimalCast(source, result, count, + parameters, width, scale); case PhysicalType::INT128: - return VectorCastHelpers::TemplatedDecimalCast( - source, result, count, parameters.error_message, width, scale); + return VectorCastHelpers::TemplatedDecimalCast(source, result, count, + parameters, width, scale); default: throw InternalException("Unimplemented internal type for decimal"); } @@ -186529,19 +188230,19 @@ static bool FromDecimalCast(Vector &source, Vector &result, idx_t count, CastPar template struct DecimalScaleInput { - DecimalScaleInput(Vector &result_p, FACTOR_TYPE factor_p) : result(result_p), factor(factor_p) { + DecimalScaleInput(Vector &result_p, FACTOR_TYPE factor_p, CastParameters ¶meters) + : result(result_p), vector_cast_data(result, parameters), factor(factor_p) { } - DecimalScaleInput(Vector &result_p, LIMIT_TYPE limit_p, FACTOR_TYPE factor_p, string *error_message_p, + DecimalScaleInput(Vector &result_p, LIMIT_TYPE limit_p, FACTOR_TYPE factor_p, CastParameters ¶meters, uint8_t source_width_p, uint8_t source_scale_p) - : result(result_p), limit(limit_p), factor(factor_p), error_message(error_message_p), + : result(result_p), vector_cast_data(result, parameters), limit(limit_p), factor(factor_p), source_width(source_width_p), source_scale(source_scale_p) { } Vector &result; + VectorTryCastData vector_cast_data; LIMIT_TYPE limit; FACTOR_TYPE factor; - bool all_converted = true; - string *error_message; uint8_t source_width; uint8_t source_scale; }; @@ -186562,36 +188263,34 @@ struct DecimalScaleUpCheckOperator { auto error = StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!", Decimal::ToString(input, data->source_width, data->source_scale), data->result.GetType().ToString()); - return HandleVectorCastError::Operation(std::move(error), mask, idx, data->error_message, - data->all_converted); + return HandleVectorCastError::Operation(std::move(error), mask, idx, data->vector_cast_data); } return Cast::Operation(input) * data->factor; } }; template -bool TemplatedDecimalScaleUp(Vector &source, Vector &result, idx_t count, string *error_message) { +bool TemplatedDecimalScaleUp(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { auto source_scale = DecimalType::GetScale(source.GetType()); auto source_width = DecimalType::GetWidth(source.GetType()); auto result_scale = DecimalType::GetScale(result.GetType()); auto result_width = DecimalType::GetWidth(result.GetType()); D_ASSERT(result_scale >= source_scale); idx_t scale_difference = result_scale - source_scale; - DEST multiply_factor = POWERS_DEST::POWERS_OF_TEN[scale_difference]; + DEST multiply_factor = UnsafeNumericCast(POWERS_DEST::POWERS_OF_TEN[scale_difference]); idx_t target_width = result_width - scale_difference; if (source_width < target_width) { - DecimalScaleInput input(result, multiply_factor); + DecimalScaleInput input(result, multiply_factor, parameters); // type will always fit: no need to check limit UnaryExecutor::GenericExecute(source, result, count, &input); return true; } else { // type might not fit: check limit - auto limit = POWERS_SOURCE::POWERS_OF_TEN[target_width]; - DecimalScaleInput input(result, limit, multiply_factor, error_message, source_width, - source_scale); + auto limit = UnsafeNumericCast(POWERS_SOURCE::POWERS_OF_TEN[target_width]); + DecimalScaleInput input(result, limit, multiply_factor, parameters, source_width, source_scale); UnaryExecutor::GenericExecute(source, result, count, &input, - error_message); - return input.all_converted; + parameters.error_message); + return input.vector_cast_data.all_converted; } } @@ -186611,15 +188310,14 @@ struct DecimalScaleDownCheckOperator { auto error = StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!", Decimal::ToString(input, data->source_width, data->source_scale), data->result.GetType().ToString()); - return HandleVectorCastError::Operation(std::move(error), mask, idx, data->error_message, - data->all_converted); + return HandleVectorCastError::Operation(std::move(error), mask, idx, data->vector_cast_data); } return Cast::Operation(input / data->factor); } }; template -bool TemplatedDecimalScaleDown(Vector &source, Vector &result, idx_t count, string *error_message) { +bool TemplatedDecimalScaleDown(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { auto source_scale = DecimalType::GetScale(source.GetType()); auto source_width = DecimalType::GetWidth(source.GetType()); auto result_scale = DecimalType::GetScale(result.GetType()); @@ -186627,19 +188325,20 @@ bool TemplatedDecimalScaleDown(Vector &source, Vector &result, idx_t count, stri D_ASSERT(result_scale < source_scale); idx_t scale_difference = source_scale - result_scale; idx_t target_width = result_width + scale_difference; - SOURCE divide_factor = POWERS_SOURCE::POWERS_OF_TEN[scale_difference]; + auto divide_factor = UnsafeNumericCast(POWERS_SOURCE::POWERS_OF_TEN[scale_difference]); if (source_width < target_width) { - DecimalScaleInput input(result, divide_factor); + DecimalScaleInput input(result, divide_factor, parameters); // type will always fit: no need to check limit UnaryExecutor::GenericExecute(source, result, count, &input); return true; } else { // type might not fit: check limit - auto limit = POWERS_SOURCE::POWERS_OF_TEN[target_width]; - DecimalScaleInput input(result, limit, divide_factor, error_message, source_width, source_scale); + + auto limit = UnsafeNumericCast(POWERS_SOURCE::POWERS_OF_TEN[target_width]); + DecimalScaleInput input(result, limit, divide_factor, parameters, source_width, source_scale); UnaryExecutor::GenericExecute(source, result, count, &input, - error_message); - return input.all_converted; + parameters.error_message); + return input.vector_cast_data.all_converted; } } @@ -186656,16 +188355,16 @@ static bool DecimalDecimalCastSwitch(Vector &source, Vector &result, idx_t count switch (result.GetType().InternalType()) { case PhysicalType::INT16: return TemplatedDecimalScaleUp(source, result, count, - parameters.error_message); + parameters); case PhysicalType::INT32: return TemplatedDecimalScaleUp(source, result, count, - parameters.error_message); + parameters); case PhysicalType::INT64: return TemplatedDecimalScaleUp(source, result, count, - parameters.error_message); + parameters); case PhysicalType::INT128: return TemplatedDecimalScaleUp(source, result, count, - parameters.error_message); + parameters); default: throw NotImplementedException("Unimplemented internal type for decimal"); } @@ -186673,17 +188372,13 @@ static bool DecimalDecimalCastSwitch(Vector &source, Vector &result, idx_t count // divide switch (result.GetType().InternalType()) { case PhysicalType::INT16: - return TemplatedDecimalScaleDown(source, result, count, - parameters.error_message); + return TemplatedDecimalScaleDown(source, result, count, parameters); case PhysicalType::INT32: - return TemplatedDecimalScaleDown(source, result, count, - parameters.error_message); + return TemplatedDecimalScaleDown(source, result, count, parameters); case PhysicalType::INT64: - return TemplatedDecimalScaleDown(source, result, count, - parameters.error_message); + return TemplatedDecimalScaleDown(source, result, count, parameters); case PhysicalType::INT128: - return TemplatedDecimalScaleDown(source, result, count, - parameters.error_message); + return TemplatedDecimalScaleDown(source, result, count, parameters); default: throw NotImplementedException("Unimplemented internal type for decimal"); } @@ -186819,6 +188514,10 @@ bool DefaultCasts::NopCast(Vector &source, Vector &result, idx_t count, CastPara return true; } +void HandleCastError::AssignError(const string &error_message, CastParameters ¶meters) { + AssignError(error_message, parameters.error_message, parameters.query_location); +} + static string UnimplementedCastMessage(const LogicalType &source_type, const LogicalType &target_type) { return StringUtil::Format("Unimplemented type for cast (%s -> %s)", source_type.ToString(), target_type.ToString()); } @@ -186827,8 +188526,7 @@ static string UnimplementedCastMessage(const LogicalType &source_type, const Log bool DefaultCasts::TryVectorNullCast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { bool success = true; if (VectorOperations::HasNotNull(source, count)) { - HandleCastError::AssignError(UnimplementedCastMessage(source.GetType(), result.GetType()), - parameters.error_message); + HandleCastError::AssignError(UnimplementedCastMessage(source.GetType(), result.GetType()), parameters); success = false; } result.SetVectorType(VectorType::CONSTANT_VECTOR); @@ -186939,11 +188637,11 @@ BoundCastInfo DefaultCasts::GetDefaultCastFunction(BindCastInput &input, const L + namespace duckdb { template bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { - bool all_converted = true; result.SetVectorType(VectorType::FLAT_VECTOR); auto &str_vec = EnumType::GetValuesInsertOrder(source.GetType()); @@ -186961,6 +188659,7 @@ bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &p auto result_data = FlatVector::GetData(result); auto &result_mask = FlatVector::Validity(result); + VectorTryCastData vector_cast_data(result, parameters); for (idx_t i = 0; i < count; i++) { auto src_idx = source_sel->get_index(i); if (!source_mask.RowIsValid(src_idx)) { @@ -186972,16 +188671,15 @@ bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &p // key doesn't exist on result enum if (!parameters.error_message) { result_data[i] = HandleVectorCastError::Operation( - CastExceptionText(source_data[src_idx]), result_mask, i, - parameters.error_message, all_converted); + CastExceptionText(source_data[src_idx]), result_mask, i, vector_cast_data); } else { result_mask.SetInvalid(i); } continue; } - result_data[i] = key; + result_data[i] = UnsafeNumericCast(key); } - return all_converted; + return vector_cast_data.all_converted; } template @@ -187270,7 +188968,7 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar // Cant cast to array, list size mismatch auto msg = StringUtil::Format("Cannot cast list with length %llu to array with length %u", ldata.length, array_size); - HandleCastError::AssignError(msg, parameters.error_message); + HandleCastError::AssignError(msg, parameters); ConstantVector::SetNull(result, true); return false; } @@ -187278,10 +188976,23 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar auto &source_cc = ListVector::GetEntry(source); auto &result_cc = ArrayVector::GetEntry(result); - // Since the list was constant, there can only be one sequence of data in the child vector CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state); - bool all_succeeded = cast_data.child_cast_info.function(source_cc, result_cc, array_size, child_parameters); - return all_succeeded; + + if (ldata.offset == 0) { + // Fast path: offset is zero, we can just cast `array_size` elements of the child vectors directly + // Since the list was constant, there can only be one sequence of data in the child vector + return cast_data.child_cast_info.function(source_cc, result_cc, array_size, child_parameters); + } + + // Else, we need to copy the range we want to cast to a new vector and cast that + // In theory we could slice the source child to create a dictionary, but we would then have to flatten the + // result child which is going to allocate a temp vector and perform a copy anyway. Since we just want to copy a + // single contiguous range with a single offset, this is simpler. + + Vector payload_vector(source_cc.GetType(), array_size); + VectorOperations::Copy(source_cc, payload_vector, ldata.offset + array_size, ldata.offset, 0); + return cast_data.child_cast_info.function(payload_vector, result_cc, array_size, child_parameters); + } else { source.Flatten(count); result.SetVectorType(VectorType::FLAT_VECTOR); @@ -187308,7 +189019,7 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar all_ok = false; auto msg = StringUtil::Format("Cannot cast list with length %llu to array with length %u", ldata[i].length, array_size); - HandleCastError::AssignError(msg, parameters.error_message); + HandleCastError::AssignError(msg, parameters); } FlatVector::SetNull(result, i, true); for (idx_t array_elem = 0; array_elem < array_size; array_elem++) { @@ -187327,13 +189038,13 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar // Fast path: No lists are null // We can just cast the child vector directly // Note: Its worth doing a CheckAllValid here, the slow path is significantly more expensive - if (FlatVector::Validity(source).CheckAllValid(count)) { + if (FlatVector::Validity(result).CheckAllValid(count)) { Vector payload_vector(result_cc.GetType(), child_count); bool ok = cast_data.child_cast_info.function(source_cc, payload_vector, child_count, child_parameters); if (all_ok && !ok) { all_ok = false; - HandleCastError::AssignError(*child_parameters.error_message, parameters.error_message); + HandleCastError::AssignError(*child_parameters.error_message, parameters); } // Now do the actual copy onto the result vector, making sure to slice properly in case the lists are out of // order @@ -187347,12 +189058,9 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar cast_chunk.Initialize(Allocator::DefaultAllocator(), {source_cc.GetType(), result_cc.GetType()}, array_size); for (idx_t i = 0; i < count; i++) { - if (FlatVector::IsNull(source, i)) { - FlatVector::SetNull(result, i, true); - // Also null the array children - for (idx_t array_elem = 0; array_elem < array_size; array_elem++) { - FlatVector::SetNull(result_cc, i * array_size + array_elem, true); - } + if (FlatVector::IsNull(result, i)) { + // We've already failed to cast this list above (e.g. length mismatch), so theres nothing to do here. + continue; } else { auto &list_cast_input = cast_chunk.data[0]; auto &list_cast_output = cast_chunk.data[1]; @@ -187365,7 +189073,7 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar cast_data.child_cast_info.function(list_cast_input, list_cast_output, array_size, child_parameters); if (all_ok && !ok) { all_ok = false; - HandleCastError::AssignError(*child_parameters.error_message, parameters.error_message); + HandleCastError::AssignError(*child_parameters.error_message, parameters); } VectorOperations::Copy(list_cast_output, result_cc, array_size, 0, i * array_size); @@ -187604,13 +189312,13 @@ BoundCastInfo DefaultCasts::PointerCastSwitch(BindCastInput &input, const Logica + namespace duckdb { template bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source_mask, const LogicalType &source_type, T *result_data, ValidityMask &result_mask, const LogicalType &result_type, idx_t count, - string *error_message, const SelectionVector *sel) { - bool all_converted = true; + VectorTryCastData &vector_cast_data, const SelectionVector *sel) { for (idx_t i = 0; i < count; i++) { idx_t source_idx = i; if (sel) { @@ -187619,17 +189327,16 @@ bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source_mask, if (source_mask.RowIsValid(source_idx)) { auto pos = EnumType::GetPos(result_type, source_data[source_idx]); if (pos == -1) { - result_data[i] = - HandleVectorCastError::Operation(CastExceptionText(source_data[source_idx]), - result_mask, i, error_message, all_converted); + result_data[i] = HandleVectorCastError::Operation( + CastExceptionText(source_data[source_idx]), result_mask, i, vector_cast_data); } else { - result_data[i] = pos; + result_data[i] = UnsafeNumericCast(pos); } } else { result_mask.SetInvalid(i); } } - return all_converted; + return vector_cast_data.all_converted; } template @@ -187644,8 +189351,9 @@ bool StringEnumCast(Vector &source, Vector &result, idx_t count, CastParameters auto result_data = ConstantVector::GetData(result); auto &result_mask = ConstantVector::Validity(result); + VectorTryCastData vector_cast_data(result, parameters); return StringEnumCastLoop(source_data, source_mask, source.GetType(), result_data, result_mask, - result.GetType(), 1, parameters.error_message, nullptr); + result.GetType(), 1, vector_cast_data, nullptr); } default: { UnifiedVectorFormat vdata; @@ -187659,8 +189367,9 @@ bool StringEnumCast(Vector &source, Vector &result, idx_t count, CastParameters auto result_data = FlatVector::GetData(result); auto &result_mask = FlatVector::Validity(result); + VectorTryCastData vector_cast_data(result, parameters); return StringEnumCastLoop(source_data, source_mask, source.GetType(), result_data, result_mask, - result.GetType(), count, parameters.error_message, source_sel); + result.GetType(), count, vector_cast_data, source_sel); } } } @@ -187742,7 +189451,7 @@ bool VectorStringToList::StringToNestedTypeCastLoop(const string_t *source_data, auto list_data = ListVector::GetData(result); auto child_data = FlatVector::GetData(varchar_vector); - bool all_converted = true; + VectorTryCastData vector_cast_data(result, parameters); idx_t total = 0; for (idx_t i = 0; i < count; i++) { idx_t idx = i; @@ -187758,7 +189467,7 @@ bool VectorStringToList::StringToNestedTypeCastLoop(const string_t *source_data, if (!VectorStringToList::SplitStringList(source_data[idx], child_data, total, varchar_vector)) { string text = "Type VARCHAR with value '" + source_data[idx].GetString() + "' can't be cast to the destination type LIST"; - HandleVectorCastError::Operation(text, result_mask, idx, parameters.error_message, all_converted); + HandleVectorCastError::Operation(text, result_mask, idx, vector_cast_data); } list_data[i].length = total - list_data[i].offset; // length is the amount of parts coming from this string } @@ -187767,8 +189476,25 @@ bool VectorStringToList::StringToNestedTypeCastLoop(const string_t *source_data, auto &result_child = ListVector::GetEntry(result); auto &cast_data = parameters.cast_data->Cast(); CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state); - return cast_data.child_cast_info.function(varchar_vector, result_child, total_list_size, child_parameters) && - all_converted; + bool all_converted = + cast_data.child_cast_info.function(varchar_vector, result_child, total_list_size, child_parameters) && + vector_cast_data.all_converted; + if (!all_converted && parameters.nullify_parent) { + UnifiedVectorFormat inserted_column_data; + result_child.ToUnifiedFormat(total_list_size, inserted_column_data); + UnifiedVectorFormat parse_column_data; + varchar_vector.ToUnifiedFormat(total_list_size, parse_column_data); + // Something went wrong in the conversion, we need to nullify the parent + for (idx_t i = 0; i < count; i++) { + for (idx_t j = list_data[i].offset; j < list_data[i].offset + list_data[i].length; j++) { + if (!inserted_column_data.validity.RowIsValid(j) && parse_column_data.validity.RowIsValid(j)) { + result_mask.SetInvalid(i); + break; + } + } + } + } + return all_converted; } static LogicalType InitVarcharStructType(const LogicalType &target) { @@ -187802,7 +189528,7 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(const string_t *source_dat child_masks[child_idx].get().SetAllInvalid(count); } - bool all_converted = true; + VectorTryCastData vector_cast_data(result, parameters); for (idx_t i = 0; i < count; i++) { idx_t idx = i; if (sel) { @@ -187819,9 +189545,9 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(const string_t *source_dat string text = "Type VARCHAR with value '" + source_data[idx].GetString() + "' can't be cast to the destination type STRUCT"; for (auto &child_mask : child_masks) { - child_mask.get().SetInvalid(idx); // some values may have already been found and set valid + child_mask.get().SetInvalid(i); // some values may have already been found and set valid } - HandleVectorCastError::Operation(text, result_mask, idx, parameters.error_message, all_converted); + HandleVectorCastError::Operation(text, result_mask, i, vector_cast_data); } } @@ -187835,10 +189561,10 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(const string_t *source_dat auto &child_cast_info = cast_data.child_cast_info[child_idx]; CastParameters child_parameters(parameters, child_cast_info.cast_data, lstate.local_states[child_idx]); if (!child_cast_info.function(child_varchar_vector, result_child_vector, count, child_parameters)) { - all_converted = false; + vector_cast_data.all_converted = false; } } - return all_converted; + return vector_cast_data.all_converted; } //===--------------------------------------------------------------------===// @@ -187883,7 +189609,7 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data, ListVector::SetListSize(result, total_elements); auto list_data = ListVector::GetData(result); - bool all_converted = true; + VectorTryCastData vector_cast_data(result, parameters); idx_t total = 0; for (idx_t i = 0; i < count; i++) { idx_t idx = i; @@ -187891,7 +189617,7 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data, idx = sel->get_index(i); } if (!source_mask.RowIsValid(idx)) { - result_mask.SetInvalid(idx); + result_mask.SetInvalid(i); continue; } @@ -187900,8 +189626,8 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data, varchar_key_vector, varchar_val_vector)) { string text = "Type VARCHAR with value '" + source_data[idx].GetString() + "' can't be cast to the destination type MAP"; - FlatVector::SetNull(result, idx, true); - HandleVectorCastError::Operation(text, result_mask, idx, parameters.error_message, all_converted); + FlatVector::SetNull(result, i, true); + HandleVectorCastError::Operation(text, result_mask, i, vector_cast_data); } list_data[i].length = total - list_data[i].offset; } @@ -187914,15 +189640,15 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data, CastParameters key_params(parameters, cast_data.key_cast.cast_data, lstate.key_state); if (!cast_data.key_cast.function(varchar_key_vector, result_key_child, total_elements, key_params)) { - all_converted = false; + vector_cast_data.all_converted = false; } CastParameters val_params(parameters, cast_data.value_cast.cast_data, lstate.value_state); if (!cast_data.value_cast.function(varchar_val_vector, result_val_child, total_elements, val_params)) { - all_converted = false; + vector_cast_data.all_converted = false; } auto &key_validity = FlatVector::Validity(result_key_child); - if (!all_converted) { + if (!vector_cast_data.all_converted) { for (idx_t row_idx = 0; row_idx < count; row_idx++) { if (!result_mask.RowIsValid(row_idx)) { continue; @@ -187937,7 +189663,7 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data, } } MapVector::MapConversionVerify(result, count); - return all_converted; + return vector_cast_data.all_converted; } //===--------------------------------------------------------------------===// @@ -187968,7 +189694,7 @@ bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data if (parameters.strict) { throw ConversionException(msg); } - HandleCastError::AssignError(msg, parameters.error_message); + HandleCastError::AssignError(msg, parameters); } result_mask.SetInvalid(i); } @@ -187978,7 +189704,7 @@ bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data Vector varchar_vector(LogicalType::VARCHAR, child_count); auto child_data = FlatVector::GetData(varchar_vector); - bool all_converted = true; + VectorTryCastData vector_cast_data(result, parameters); idx_t total = 0; for (idx_t i = 0; i < count; i++) { idx_t idx = i; @@ -188002,7 +189728,7 @@ bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data if (!VectorStringToList::SplitStringList(source_data[idx], child_data, total, varchar_vector)) { auto text = StringUtil::Format("Type VARCHAR with value '%s' can't be cast to the destination type ARRAY", source_data[idx].GetString()); - HandleVectorCastError::Operation(text, result_mask, idx, parameters.error_message, all_converted); + HandleVectorCastError::Operation(text, result_mask, idx, vector_cast_data); } } D_ASSERT(total == child_count); @@ -188012,7 +189738,7 @@ bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state); bool cast_result = cast_data.child_cast_info.function(varchar_vector, result_child, child_count, child_parameters); - return all_lengths_match && cast_result && all_converted; + return all_lengths_match && cast_result && vector_cast_data.all_converted; } template @@ -188117,7 +189843,7 @@ unique_ptr StructBoundCastData::BindStructToStructCast(BindCastIn auto source_is_unnamed = StructType::IsUnnamed(source); if (source_child_types.size() != result_child_types.size()) { - throw TypeMismatchException(source, target, "Cannot cast STRUCTs of different 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; @@ -188139,7 +189865,7 @@ unique_ptr StructBoundCastData::BindStructToStructCast(BindCastIn // named struct cast - find corresponding member in target auto entry = target_members.find(source_child.first); if (entry == target_members.end()) { - throw TypeMismatchException(source, target, + throw TypeMismatchException(input.query_location, source, target, "Cannot cast STRUCTs - element \"" + source_child.first + "\" in source struct was not found in target struct"); } @@ -188431,6 +190157,10 @@ BoundCastInfo DefaultCasts::TimestampNsCastSwitch(BindCastInput &input, const Lo // timestamp (ns) to timestamp (us) return BoundCastInfo( &VectorCastHelpers::TemplatedCastLoop); + case LogicalTypeId::TIMESTAMP_TZ: + // timestamp (ns) to timestamp with time zone (us) + return BoundCastInfo( + &VectorCastHelpers::TemplatedCastLoop); default: return TryVectorNullCast; } @@ -188458,6 +190188,10 @@ BoundCastInfo DefaultCasts::TimestampMsCastSwitch(BindCastInput &input, const Lo // timestamp (ms) to timestamp (ns) return BoundCastInfo( &VectorCastHelpers::TemplatedCastLoop); + case LogicalTypeId::TIMESTAMP_TZ: + // timestamp (ms) to timestamp with timezone (us) + return BoundCastInfo( + &VectorCastHelpers::TemplatedCastLoop); default: return TryVectorNullCast; } @@ -188486,6 +190220,10 @@ BoundCastInfo DefaultCasts::TimestampSecCastSwitch(BindCastInput &input, const L // timestamp (s) to timestamp (us) return BoundCastInfo( &VectorCastHelpers::TemplatedCastLoop); + case LogicalTypeId::TIMESTAMP_TZ: + // timestamp (s) to timestamp with timezone (us) + return BoundCastInfo( + &VectorCastHelpers::TemplatedCastLoop); case LogicalTypeId::TIMESTAMP_NS: // timestamp (s) to timestamp (ns) return BoundCastInfo( @@ -188644,6 +190382,7 @@ BoundCastInfo StructToUnionCast::Bind(BindCastInput &input, const LogicalType &s + #include // for std::sort namespace duckdb { @@ -188898,7 +190637,7 @@ static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastPa // map the tag auto source_tag = ConstantVector::GetData(source_tag_vector)[0]; auto mapped_tag = cast_data.tag_map[source_tag]; - ConstantVector::GetData(result_tag_vector)[0] = mapped_tag; + ConstantVector::GetData(result_tag_vector)[0] = UnsafeNumericCast(mapped_tag); } } else { // Otherwise, use the unified vector format to access the source vector. @@ -188920,7 +190659,8 @@ static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastPa // map the tag auto source_tag = (UnifiedVectorFormat::GetData(source_tag_format))[source_row_idx]; auto target_tag = cast_data.tag_map[source_tag]; - FlatVector::GetData(result_tag_vector)[row_idx] = target_tag; + FlatVector::GetData(result_tag_vector)[row_idx] = + UnsafeNumericCast(target_tag); } else { // Issue: The members of the result is not always flatvectors @@ -188944,28 +190684,24 @@ static bool UnionToVarcharCast(Vector &source, Vector &result, idx_t count, Cast UnionToUnionCast(source, varchar_union, count, parameters); // now construct the actual varchar vector - varchar_union.Flatten(count); - auto &tag_vector = UnionVector::GetTags(source); - auto tag_vector_type = tag_vector.GetVectorType(); - if (tag_vector_type != VectorType::CONSTANT_VECTOR && tag_vector_type != VectorType::FLAT_VECTOR) { - tag_vector.Flatten(count); - } + // varchar_union.Flatten(count); + auto &tag_vector = UnionVector::GetTags(varchar_union); + UnifiedVectorFormat tag_format; + tag_vector.ToUnifiedFormat(count, tag_format); - auto tags = FlatVector::GetData(tag_vector); - - auto &validity = FlatVector::Validity(varchar_union); auto result_data = FlatVector::GetData(result); for (idx_t i = 0; i < count; i++) { - if (!validity.RowIsValid(i)) { + auto tag_idx = tag_format.sel->get_index(i); + if (!tag_format.validity.RowIsValid(tag_idx)) { FlatVector::SetNull(result, i, true); continue; } - auto &member = UnionVector::GetMember(varchar_union, tags[i]); + auto tag = UnifiedVectorFormat::GetData(tag_format)[tag_idx]; + auto &member = UnionVector::GetMember(varchar_union, tag); UnifiedVectorFormat member_vdata; member.ToUnifiedFormat(count, member_vdata); - auto mapped_idx = member_vdata.sel->get_index(i); auto member_valid = member_vdata.validity.RowIsValid(mapped_idx); if (member_valid) { @@ -189362,7 +191098,7 @@ bool VectorStringToStruct::SplitStruct(const string_t &input, vector(key_end - key_start)); auto it = child_names.find(found_key); if (it == child_names.end()) { @@ -189383,6 +191119,7 @@ bool VectorStringToStruct::SplitStruct(const string_t &input, vector(ImplicitCast(from_member_type, to_member_type)); if (child_cost > cost) { cost = child_cost; } @@ -191250,6 +192987,7 @@ string PragmaFunction::ToString() const { + namespace duckdb { static string IntegralCompressFunctionName(const LogicalType &result_type) { @@ -191261,7 +192999,7 @@ template struct TemplatedIntegralCompress { static inline RESULT_TYPE Operation(const INPUT_TYPE &input, const INPUT_TYPE &min_val) { D_ASSERT(min_val <= input); - return input - min_val; + return UnsafeNumericCast(input - min_val); } }; @@ -191269,7 +193007,7 @@ template struct TemplatedIntegralCompress { static inline RESULT_TYPE Operation(const hugeint_t &input, const hugeint_t &min_val) { D_ASSERT(min_val <= input); - return (input - min_val).lower; + return UnsafeNumericCast((input - min_val).lower); } }; @@ -191277,7 +193015,7 @@ template struct TemplatedIntegralCompress { static inline RESULT_TYPE Operation(const uhugeint_t &input, const uhugeint_t &min_val) { D_ASSERT(min_val <= input); - return (input - min_val).lower; + return UnsafeNumericCast((input - min_val).lower); } }; @@ -191344,7 +193082,7 @@ static string IntegralDecompressFunctionName(const LogicalType &result_type) { template static inline RESULT_TYPE TemplatedIntegralDecompress(const INPUT_TYPE &input, const RESULT_TYPE &min_val) { - return min_val + input; + return UnsafeNumericCast(min_val + input); } template @@ -191512,7 +193250,7 @@ static inline RESULT_TYPE StringCompressInternal(const string_t &input) { ReverseMemCpy(result_ptr + remainder, data_ptr_cast(input.GetPointer()), input.GetSize()); memset(result_ptr, '\0', remainder); } - result_ptr[0] = input.GetSize(); + result_ptr[0] = UnsafeNumericCast(input.GetSize()); return result; } @@ -191525,11 +193263,11 @@ static inline RESULT_TYPE StringCompress(const string_t &input) { template static inline RESULT_TYPE MiniStringCompress(const string_t &input) { if (sizeof(RESULT_TYPE) <= string_t::INLINE_LENGTH) { - return input.GetSize() + *const_data_ptr_cast(input.GetPrefix()); + return UnsafeNumericCast(input.GetSize() + *const_data_ptr_cast(input.GetPrefix())); } else if (input.GetSize() == 0) { return 0; } else { - return input.GetSize() + *const_data_ptr_cast(input.GetPointer()); + return UnsafeNumericCast(input.GetSize() + *const_data_ptr_cast(input.GetPointer())); } } @@ -192406,7 +194144,8 @@ namespace duckdb { void ListResizeFunction(DataChunk &args, ExpressionState &state, Vector &result) { D_ASSERT(args.data[1].GetType().id() == LogicalTypeId::UBIGINT); if (result.GetType().id() == LogicalTypeId::SQLNULL) { - FlatVector::SetNull(result, 0, true); + result.SetVectorType(VectorType::CONSTANT_VECTOR); + ConstantVector::SetNull(result, true); return; } D_ASSERT(result.GetType().id() == LogicalTypeId::LIST); @@ -192443,6 +194182,7 @@ void ListResizeFunction(DataChunk &args, ExpressionState &state, Vector &result) optional_ptr default_vector; if (args.ColumnCount() == 3) { default_vector = &args.data[2]; + default_vector->Flatten(count); default_vector->ToUnifiedFormat(count, default_data); default_vector->SetVectorType(VectorType::CONSTANT_VECTOR); } @@ -192761,10 +194501,9 @@ static void ListZipFunction(DataChunk &args, ExpressionState &state, Vector &res } vector input_lists; + input_lists.resize(args.ColumnCount()); for (idx_t i = 0; i < args.ColumnCount(); i++) { - UnifiedVectorFormat curr; - args.data[i].ToUnifiedFormat(count, curr); - input_lists.push_back(curr); + args.data[i].ToUnifiedFormat(count, input_lists[i]); } // Handling output row for each input row @@ -192816,7 +194555,7 @@ static void ListZipFunction(DataChunk &args, ExpressionState &state, Vector &res for (idx_t j = 0; j < count; j++) { idx_t len = lengths[j]; for (idx_t i = 0; i < args_size; i++) { - UnifiedVectorFormat curr = input_lists[i]; + auto &curr = input_lists[i]; idx_t sel_idx = curr.sel->get_index(j); idx_t curr_off = 0; idx_t curr_len = 0; @@ -192918,9 +194657,6 @@ void MapUtil::ReinterpretMap(Vector &result, Vector &input, idx_t count) { auto &result_struct = ListVector::GetEntry(result); FlatVector::SetValidity(result_struct, input_struct_data.validity); - // Set the right vector type - result.SetVectorType(input.GetVectorType()); - // Copy the list size auto list_size = ListVector::GetListSize(input); ListVector::SetListSize(result, list_size); @@ -192935,6 +194671,13 @@ void MapUtil::ReinterpretMap(Vector &result, Vector &input, idx_t count) { auto &input_values = MapVector::GetValues(input); auto &result_values = MapVector::GetValues(result); result_values.Reference(input_values); + + if (input.GetVectorType() == VectorType::DICTIONARY_VECTOR) { + result.Slice(*input_data.sel, count); + } + + // Set the right vector type + result.SetVectorType(input.GetVectorType()); } void BuiltinFunctions::RegisterNestedFunctions() { @@ -193481,7 +195224,7 @@ unique_ptr BindDecimalAddSubtract(ClientContext &context, ScalarFu } D_ASSERT(max_width > 0); // for addition/subtraction, we add 1 to the width to ensure we don't overflow - auto required_width = MaxValue(max_scale + max_width_over_scale, max_width) + 1; + auto required_width = NumericCast(MaxValue(max_scale + max_width_over_scale, max_width) + 1); if (required_width > Decimal::MAX_WIDTH_INT64 && max_width <= Decimal::MAX_WIDTH_INT64) { // we don't automatically promote past the hugeint boundary to avoid the large hugeint performance penalty bind_data->check_overflow = true; @@ -194292,6 +196035,7 @@ void ModFun::RegisterFunction(BuiltinFunctions &set) { + #include #include @@ -194314,8 +196058,9 @@ double MultiplyOperator::Operation(double left, double right) { template <> interval_t MultiplyOperator::Operation(interval_t left, int64_t right) { - left.months = MultiplyOperatorOverflowCheck::Operation(left.months, right); - left.days = MultiplyOperatorOverflowCheck::Operation(left.days, right); + const auto right32 = Cast::Operation(right); + left.months = MultiplyOperatorOverflowCheck::Operation(left.months, right32); + left.days = MultiplyOperatorOverflowCheck::Operation(left.days, right32); left.micros = MultiplyOperatorOverflowCheck::Operation(left.micros, right); return left; } @@ -194576,9 +196321,15 @@ date_t SubtractOperator::Operation(date_t left, int32_t right) { template <> interval_t SubtractOperator::Operation(interval_t left, interval_t right) { interval_t result; - result.months = left.months - right.months; - result.days = left.days - right.days; - result.micros = left.micros - right.micros; + if (!TrySubtractOperator::Operation(left.months, right.months, result.months)) { + throw OutOfRangeException("Interval months subtraction out of range"); + } + if (!TrySubtractOperator::Operation(left.days, right.days, result.days)) { + throw OutOfRangeException("Interval days subtraction out of range"); + } + if (!TrySubtractOperator::Operation(left.micros, right.micros, result.micros)) { + throw OutOfRangeException("Interval micros subtraction out of range"); + } return result; } @@ -195334,7 +197085,7 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t break; } case StrTimeSpecifier::MONTH_DECIMAL: { - target = Write2(target, data[1]); + target = Write2(target, UnsafeNumericCast(data[1])); break; } case StrTimeSpecifier::YEAR_WITHOUT_CENTURY: { @@ -195342,7 +197093,7 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t break; } case StrTimeSpecifier::HOUR_24_DECIMAL: { - target = Write2(target, data[3]); + target = Write2(target, UnsafeNumericCast(data[3])); break; } case StrTimeSpecifier::HOUR_12_DECIMAL: { @@ -195350,15 +197101,15 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t if (hour == 0) { hour = 12; } - target = Write2(target, hour); + target = Write2(target, UnsafeNumericCast(hour)); break; } case StrTimeSpecifier::MINUTE_DECIMAL: { - target = Write2(target, data[4]); + target = Write2(target, UnsafeNumericCast(data[4])); break; } case StrTimeSpecifier::SECOND_DECIMAL: { - target = Write2(target, data[5]); + target = Write2(target, UnsafeNumericCast(data[5])); break; } default: @@ -195698,7 +197449,7 @@ int32_t StrpTimeFormat::TryParseCollection(const char *data, idx_t &pos, idx_t s if (i == entry_size) { // full match pos += entry_size; - return c; + return UnsafeNumericCast(c); } } return -1; @@ -195829,7 +197580,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const { return false; } // day of the month - result_data[2] = number; + result_data[2] = UnsafeNumericCast(number); offset_specifier = specifiers[i]; break; case StrTimeSpecifier::MONTH_DECIMAL_PADDED: @@ -195840,7 +197591,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const { return false; } // month number - result_data[1] = number; + result_data[1] = UnsafeNumericCast(number); offset_specifier = specifiers[i]; break; case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED: @@ -195883,7 +197634,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const { break; } // year as full number - result_data[0] = number; + result_data[0] = UnsafeNumericCast(number); break; case StrTimeSpecifier::YEAR_ISO: switch (offset_specifier) { @@ -195932,7 +197683,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const { return false; } // hour as full number - result_data[3] = number; + result_data[3] = UnsafeNumericCast(number); break; case StrTimeSpecifier::HOUR_12_PADDED: case StrTimeSpecifier::HOUR_12_DECIMAL: @@ -195942,7 +197693,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const { return false; } // 12-hour number: start off by just storing the number - result_data[3] = number; + result_data[3] = UnsafeNumericCast(number); break; case StrTimeSpecifier::MINUTE_PADDED: case StrTimeSpecifier::MINUTE_DECIMAL: @@ -195952,7 +197703,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const { return false; } // minutes - result_data[4] = number; + result_data[4] = UnsafeNumericCast(number); break; case StrTimeSpecifier::SECOND_PADDED: case StrTimeSpecifier::SECOND_DECIMAL: @@ -195962,22 +197713,23 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const { return false; } // seconds - result_data[5] = number; + result_data[5] = UnsafeNumericCast(number); break; case StrTimeSpecifier::NANOSECOND_PADDED: D_ASSERT(number < Interval::NANOS_PER_SEC); // enforced by the length of the number // microseconds (rounded) - result_data[6] = (number + Interval::NANOS_PER_MICRO / 2) / Interval::NANOS_PER_MICRO; + result_data[6] = + UnsafeNumericCast((number + Interval::NANOS_PER_MICRO / 2) / Interval::NANOS_PER_MICRO); break; case StrTimeSpecifier::MICROSECOND_PADDED: D_ASSERT(number < Interval::MICROS_PER_SEC); // enforced by the length of the number // microseconds - result_data[6] = number; + result_data[6] = UnsafeNumericCast(number); break; case StrTimeSpecifier::MILLISECOND_PADDED: D_ASSERT(number < Interval::MSECS_PER_SEC); // enforced by the length of the number // microseconds - result_data[6] = number * Interval::MICROS_PER_MSEC; + result_data[6] = UnsafeNumericCast(number * Interval::MICROS_PER_MSEC); break; case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST: case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST: @@ -196239,11 +197991,11 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const { iso_week = (iso_week > 53) ? 1 : iso_week; iso_weekday = (iso_weekday > 7) ? 1 : iso_weekday; // Gregorian and ISO agree on the year of January 4 - auto jan4 = Date::FromDate(iso_year, 1, 4); + auto jan4 = Date::FromDate(UnsafeNumericCast(iso_year), 1, 4); // ISO Week 1 starts on the previous Monday auto week1 = Date::GetMondayOfCurrentWeek(jan4); // ISO Week N starts N-1 weeks later - auto iso_date = week1 + (iso_week - 1) * 7 + (iso_weekday - 1); + auto iso_date = week1 + UnsafeNumericCast((iso_week - 1) * 7 + (iso_weekday - 1)); Date::Convert(iso_date, result_data[0], result_data[1], result_data[2]); break; } @@ -196259,14 +198011,14 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const { yeardate -= int(offset_specifier == StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST); // Is there a week 0? yeardate -= 7 * int(yeardate >= jan1); - yeardate += weekno * 7 + weekday; + yeardate += UnsafeNumericCast(weekno * 7 + weekday); Date::Convert(yeardate, result_data[0], result_data[1], result_data[2]); break; } case StrTimeSpecifier::DAY_OF_YEAR_PADDED: case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL: { auto yeardate = Date::FromDate(result_data[0], 1, 1); - yeardate += yearday - 1; + yeardate += UnsafeNumericCast(yearday - 1); Date::Convert(yeardate, result_data[0], result_data[1], result_data[2]); break; } @@ -197267,12 +199019,23 @@ void LengthFun::RegisterFunction(BuiltinFunctions &set) { namespace duckdb { struct StandardCharacterReader { + static void NextCharacter(const char *sdata, idx_t slen, idx_t &sidx) { + sidx++; + while (sidx < slen && !LengthFun::IsCharacter(sdata[sidx])) { + sidx++; + } + } + static char Operation(const char *data, idx_t pos) { return data[pos]; } }; struct ASCIILCaseReader { + static void NextCharacter(const char *sdata, idx_t slen, idx_t &sidx) { + sidx++; + } + static char Operation(const char *data, idx_t pos) { return (char)LowerFun::ascii_to_lower_map[(uint8_t)data[pos]]; } @@ -197295,7 +199058,7 @@ bool TemplatedLikeOperator(const char *sdata, idx_t slen, const char *pdata, idx } sidx++; } else if (pchar == UNDERSCORE) { - sidx++; + READER::NextCharacter(sdata, slen, sidx); } else if (pchar == PERCENTAGE) { pidx++; while (pidx < plen && pdata[pidx] == PERCENTAGE) { @@ -197657,8 +199420,8 @@ bool ILikeOperatorFunction(string_t &str, string_t &pattern, char escape = '\0') idx_t pat_llength = LowerFun::LowerLength(pat_data, pat_size); auto pat_ldata = make_unsafe_uniq_array(pat_llength); LowerFun::LowerCase(pat_data, pat_size, pat_ldata.get()); - string_t str_lcase(str_ldata.get(), str_llength); - string_t pat_lcase(pat_ldata.get(), pat_llength); + string_t str_lcase(str_ldata.get(), UnsafeNumericCast(str_llength)); + string_t pat_lcase(pat_ldata.get(), UnsafeNumericCast(pat_llength)); return LikeOperatorFunction(str_lcase, pat_lcase, escape); } @@ -197980,7 +199743,8 @@ void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_ bool throw_on_group_found = (idx_t)group > args.size; idx_t startpos = 0; - for (idx_t iteration = 0; ExtractAll(input, pattern, &startpos, args.group_buffer, args.size); iteration++) { + for (idx_t iteration = 0; + ExtractAll(input, pattern, &startpos, args.group_buffer, UnsafeNumericCast(args.size)); iteration++) { if (!iteration && throw_on_group_found) { throw InvalidInputException("Pattern has %d groups. Cannot access group %d", args.size, group); } @@ -198008,7 +199772,8 @@ void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_ // the 'match_group' address is guaranteed to be bigger than that of the source D_ASSERT(const_char_ptr_cast(match_group.begin()) >= string.GetData()); idx_t offset = match_group.begin() - string.GetData(); - list_content[child_idx] = string_t(string.GetData() + offset, match_group.size()); + list_content[child_idx] = + string_t(string.GetData() + offset, UnsafeNumericCast(match_group.size())); } current_list_size++; if (startpos > input.size()) { @@ -198510,13 +200275,14 @@ static void RegexExtractStructFunction(DataChunk &args, ExpressionState &state, ConstantVector::SetNull(result, false); auto idata = ConstantVector::GetData(input); auto str = CreateStringPiece(idata[0]); - auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(), groups.size()); + auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(), + UnsafeNumericCast(groups.size())); for (size_t col = 0; col < child_entries.size(); ++col) { auto &child_entry = child_entries[col]; ConstantVector::SetNull(*child_entry, false); auto &extracted = ws[col]; auto cdata = ConstantVector::GetData(*child_entry); - cdata[0] = string_t(extracted.data(), match ? extracted.size() : 0); + cdata[0] = string_t(extracted.data(), UnsafeNumericCast(match ? extracted.size() : 0)); } } } else { @@ -198539,12 +200305,13 @@ static void RegexExtractStructFunction(DataChunk &args, ExpressionState &state, const auto idx = iunified.sel->get_index(i); if (ivalidity.RowIsValid(idx)) { auto str = CreateStringPiece(idata[idx]); - auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(), groups.size()); + auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(), + UnsafeNumericCast(groups.size())); for (size_t col = 0; col < child_entries.size(); ++col) { auto &child_entry = child_entries[col]; auto cdata = FlatVector::GetData(*child_entry); auto &extracted = ws[col]; - cdata[i] = string_t(extracted.data(), match ? extracted.size() : 0); + cdata[i] = string_t(extracted.data(), UnsafeNumericCast(match ? extracted.size() : 0)); } } else { FlatVector::SetNull(result, i, true); @@ -199105,7 +200872,7 @@ static bool SuffixFunction(const string_t &str, const string_t &suffix) { auto suffix_data = suffix.GetData(); auto str_data = str.GetData(); - int32_t suf_idx = suffix_size - 1; + auto suf_idx = UnsafeNumericCast(suffix_size) - 1; idx_t str_idx = str_size - 1; for (; suf_idx >= 0; --suf_idx, --str_idx) { if (suffix_data[suf_idx] != str_data[str_idx]) { @@ -199805,9 +201572,39 @@ string ScalarMacroFunction::ToSQL(const string &schema, const string &name) cons } // namespace duckdb +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/common/types/arrow_aux_data.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + + +namespace duckdb { + +struct ArrowAuxiliaryData : public VectorAuxiliaryData { + static constexpr const VectorAuxiliaryDataType TYPE = VectorAuxiliaryDataType::ARROW_AUXILIARY; + explicit ArrowAuxiliaryData(shared_ptr arrow_array_p) + : VectorAuxiliaryData(VectorAuxiliaryDataType::ARROW_AUXILIARY), arrow_array(std::move(arrow_array_p)) { + } + ~ArrowAuxiliaryData() override { + } + + shared_ptr arrow_array; +}; + +} // namespace duckdb + + namespace duckdb { ArrowArrayScanState::ArrowArrayScanState(ArrowScanLocalState &state) : state(state) { + arrow_dictionary = nullptr; } ArrowArrayScanState &ArrowArrayScanState::GetChild(idx_t child_idx) { @@ -199815,20 +201612,43 @@ ArrowArrayScanState &ArrowArrayScanState::GetChild(idx_t child_idx) { if (it == children.end()) { auto child_p = make_uniq(state); auto &child = *child_p; + child.owned_data = owned_data; children.emplace(std::make_pair(child_idx, std::move(child_p))); return child; } + if (!it->second->owned_data) { + // Propagate down the ownership, for dictionaries in children + D_ASSERT(owned_data); + it->second->owned_data = owned_data; + } return *it->second; } -void ArrowArrayScanState::AddDictionary(unique_ptr dictionary_p) { - this->dictionary = std::move(dictionary_p); +void ArrowArrayScanState::AddDictionary(unique_ptr dictionary_p, ArrowArray *arrow_dict) { + dictionary = std::move(dictionary_p); + D_ASSERT(owned_data); + D_ASSERT(arrow_dict); + arrow_dictionary = arrow_dict; + // Make sure the data referenced by the dictionary stays alive + dictionary->GetBuffer()->SetAuxiliaryData(make_uniq(owned_data)); } bool ArrowArrayScanState::HasDictionary() const { return dictionary != nullptr; } +bool ArrowArrayScanState::CacheOutdated(ArrowArray *dictionary) const { + if (!dictionary) { + // Not cached + return true; + } + if (dictionary == arrow_dictionary.get()) { + // Already cached, not outdated + return false; + } + return true; +} + Vector &ArrowArrayScanState::GetDictionary() { D_ASSERT(HasDictionary()); return *dictionary; @@ -199991,13 +201811,30 @@ static unique_ptr GetArrowLogicalTypeNoDictionary(ArrowSchema &schema } 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) - std::string parameters = format.substr(format.find(':')); - uint8_t width = std::stoi(parameters.substr(1, parameters.find(','))); - uint8_t scale = std::stoi(parameters.substr(parameters.find(',') + 1)); - if (width > 38) { + 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(width, scale)); + return make_uniq(LogicalType::DECIMAL(NumericCast(width), NumericCast(scale))); } else if (format == "u") { return make_uniq(LogicalType::VARCHAR, ArrowVariableSizeType::NORMAL); } else if (format == "U") { @@ -200052,7 +201889,7 @@ static unique_ptr GetArrowLogicalTypeNoDictionary(ArrowSchema &schema std::string parameters = format.substr(format.find(':') + 1); idx_t fixed_size = std::stoi(parameters); auto child_type = ArrowTableFunction::GetArrowLogicalType(*schema.children[0]); - auto list_type = make_uniq(LogicalType::LIST(child_type->GetDuckType()), fixed_size); + auto list_type = make_uniq(LogicalType::ARRAY(child_type->GetDuckType(), fixed_size), fixed_size); list_type->AddChild(std::move(child_type)); return list_type; } else if (format == "+s") { @@ -200355,33 +202192,6 @@ void BuiltinFunctions::RegisterArrowFunctions() { -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/common/types/arrow_aux_data.hpp -// -// -//===----------------------------------------------------------------------===// - - - - - - -namespace duckdb { - -struct ArrowAuxiliaryData : public VectorAuxiliaryData { - static constexpr const VectorAuxiliaryDataType TYPE = VectorAuxiliaryDataType::ARROW_AUXILIARY; - explicit ArrowAuxiliaryData(shared_ptr arrow_array_p) - : VectorAuxiliaryData(VectorAuxiliaryDataType::ARROW_AUXILIARY), arrow_array(std::move(arrow_array_p)) { - } - ~ArrowAuxiliaryData() override { - } - - shared_ptr arrow_array; -}; - -} // namespace duckdb @@ -200409,7 +202219,7 @@ static void ShiftRight(unsigned char *ar, int size, int shift) { while (shift--) { for (int i = size - 1; i >= 0; --i) { int next = (ar[i] & 1) ? 0x80 : 0; - ar[i] = carry | (ar[i] >> 1); + ar[i] = UnsafeNumericCast(carry | (ar[i] >> 1)); carry = next; } } @@ -200453,7 +202263,7 @@ static void GetValidityMask(ValidityMask &mask, ArrowArray &array, const ArrowSc //! need to re-align nullmask vector temp_nullmask(n_bitmask_bytes + 1); memcpy(temp_nullmask.data(), ArrowBufferData(array, 0) + bit_offset / 8, n_bitmask_bytes + 1); - ShiftRight(temp_nullmask.data(), n_bitmask_bytes + 1, + ShiftRight(temp_nullmask.data(), NumericCast(n_bitmask_bytes + 1), bit_offset % 8); //! why this has to be a right shift is a mystery to me memcpy((void *)mask.GetData(), data_ptr_cast(temp_nullmask.data()), n_bitmask_bytes); } @@ -200509,20 +202319,7 @@ static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowArrayScanS SetValidityMask(vector, array, scan_state, size, parent_offset, nested_offset); idx_t start_offset = 0; idx_t cur_offset = 0; - if (size_type == ArrowVariableSizeType::FIXED_SIZE) { - auto fixed_size = arrow_type.FixedSize(); - //! Have to check validity mask before setting this up - idx_t offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset) * fixed_size; - start_offset = offset; - auto list_data = FlatVector::GetData(vector); - for (idx_t i = 0; i < size; i++) { - auto &le = list_data[i]; - le.offset = cur_offset; - le.length = fixed_size; - cur_offset += fixed_size; - } - list_size = start_offset + cur_offset; - } else if (size_type == ArrowVariableSizeType::NORMAL) { + if (size_type == ArrowVariableSizeType::NORMAL) { auto offsets = ArrowBufferData(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset); start_offset = offsets[0]; @@ -200589,6 +202386,61 @@ static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowArrayScanS } } +static void ArrowToDuckDBArray(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size, + const ArrowType &arrow_type, int64_t nested_offset, ValidityMask *parent_mask, + int64_t parent_offset) { + + D_ASSERT(arrow_type.GetSizeType() == ArrowVariableSizeType::FIXED_SIZE); + auto &scan_state = array_state.state; + auto array_size = arrow_type.FixedSize(); + auto child_count = array_size * size; + auto child_offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset) * array_size; + + SetValidityMask(vector, array, scan_state, size, parent_offset, nested_offset); + + auto &child_vector = ArrayVector::GetEntry(vector); + SetValidityMask(child_vector, *array.children[0], scan_state, child_count, array.offset, child_offset); + + auto &array_mask = FlatVector::Validity(vector); + if (parent_mask) { + //! Since this List is owned by a struct we must guarantee their validity map matches on Null + if (!parent_mask->AllValid()) { + for (idx_t i = 0; i < size; i++) { + if (!parent_mask->RowIsValid(i)) { + array_mask.SetInvalid(i); + } + } + } + } + + // Broadcast the validity mask to the child vector + if (!array_mask.AllValid()) { + auto &child_validity_mask = FlatVector::Validity(child_vector); + for (idx_t i = 0; i < size; i++) { + if (!array_mask.RowIsValid(i)) { + for (idx_t j = 0; j < array_size; j++) { + child_validity_mask.SetInvalid(i * array_size + j); + } + } + } + } + + auto &child_state = array_state.GetChild(0); + auto &child_array = *array.children[0]; + auto &child_type = arrow_type[0]; + if (child_count == 0 && child_offset == 0) { + D_ASSERT(!child_array.dictionary); + ColumnArrowToDuckDB(child_vector, child_array, child_state, child_count, child_type, -1); + } else { + if (child_array.dictionary) { + ColumnArrowToDuckDBDictionary(child_vector, child_array, child_state, child_count, child_type, + child_offset); + } else { + ColumnArrowToDuckDB(child_vector, child_array, child_state, child_count, child_type, child_offset); + } + } +} + static void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state, idx_t size, const ArrowType &arrow_type, int64_t nested_offset, int64_t parent_offset) { auto size_type = arrow_type.GetSizeType(); @@ -200670,7 +202522,7 @@ static void SetVectorString(Vector &vector, idx_t size, char *cdata, T *offsets) if (str_len > NumericLimits::Maximum()) { // LCOV_EXCL_START throw ConversionException("DuckDB does not support Strings over 4GB"); } // LCOV_EXCL_STOP - strings[row_idx] = string_t(cptr, str_len); + strings[row_idx] = string_t(cptr, UnsafeNumericCast(str_len)); } } @@ -200968,9 +202820,6 @@ static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, ArrowArray &array, static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size, const ArrowType &arrow_type, int64_t nested_offset, ValidityMask *parent_mask, uint64_t parent_offset) { - if (parent_offset != 0) { - (void)array_state; - } auto &scan_state = array_state.state; D_ASSERT(!array.dictionary); @@ -201050,7 +202899,8 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca GetEffectiveOffset(array, parent_offset, scan_state, nested_offset); auto tgt_ptr = FlatVector::GetData(vector); for (idx_t row = 0; row < size; row++) { - tgt_ptr[row] = date_t(int64_t(src_ptr[row]) / static_cast(1000 * 60 * 60 * 24)); + tgt_ptr[row] = date_t( + UnsafeNumericCast(int64_t(src_ptr[row]) / static_cast(1000 * 60 * 60 * 24))); } break; } @@ -201216,6 +203066,10 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca ArrowToDuckDBList(vector, array, array_state, size, arrow_type, nested_offset, parent_mask, parent_offset); break; } + case LogicalTypeId::ARRAY: { + ArrowToDuckDBArray(vector, array, array_state, size, arrow_type, nested_offset, parent_mask, parent_offset); + break; + } case LogicalTypeId::MAP: { ArrowToDuckDBList(vector, array, array_state, size, arrow_type, nested_offset, parent_mask, parent_offset); ArrowToDuckDBMapVerify(vector, size); @@ -201450,10 +203304,10 @@ static bool CanContainNull(ArrowArray &array, ValidityMask *parent_mask) { static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size, const ArrowType &arrow_type, int64_t nested_offset, ValidityMask *parent_mask, uint64_t parent_offset) { + D_ASSERT(arrow_type.HasDictionary()); auto &scan_state = array_state.state; - const bool has_nulls = CanContainNull(array, parent_mask); - if (!array_state.HasDictionary()) { + if (array_state.CacheOutdated(array.dictionary)) { //! We need to set the dictionary data for this column auto base_vector = make_uniq(vector.GetType(), array.dictionary->length); SetValidityMask(*base_vector, *array.dictionary, scan_state, array.dictionary->length, 0, 0, has_nulls); @@ -201475,7 +203329,7 @@ static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, Arr default: throw NotImplementedException("ArrowArrayPhysicalType not recognized"); }; - array_state.AddDictionary(std::move(base_vector)); + array_state.AddDictionary(std::move(base_vector), array.dictionary); } auto offset_type = arrow_type.GetDuckType(); //! Get Pointer to Indices of Dictionary @@ -201500,6 +203354,7 @@ static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, Arr SetSelectionVector(sel, indices, offset_type, size); } vector.Slice(array_state.GetDictionary(), sel, size); + vector.Verify(size); } void ArrowTableFunction::ArrowToDuckDB(ArrowScanLocalState &scan_state, const arrow_column_map_t &arrow_convert_data, @@ -201524,20 +203379,17 @@ void ArrowTableFunction::ArrowToDuckDB(ArrowScanLocalState &scan_state, const ar if (array.length != scan_state.chunk->arrow_array.length) { throw InvalidInputException("arrow_scan: array length mismatch"); } - // Make sure this Vector keeps the Arrow chunk alive in case we can zero-copy the data - if (scan_state.arrow_owned_data.find(idx) == scan_state.arrow_owned_data.end()) { - auto arrow_data = make_shared(); - arrow_data->arrow_array = scan_state.chunk->arrow_array; - scan_state.chunk->arrow_array.release = nullptr; - scan_state.arrow_owned_data[idx] = arrow_data; - } - - output.data[idx].GetBuffer()->SetAuxiliaryData(make_uniq(scan_state.arrow_owned_data[idx])); D_ASSERT(arrow_convert_data.find(col_idx) != arrow_convert_data.end()); auto &arrow_type = *arrow_convert_data.at(col_idx); auto &array_state = scan_state.GetState(col_idx); + // Make sure this Vector keeps the Arrow chunk alive in case we can zero-copy the data + 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); switch (array_physical_type) { @@ -201693,7 +203545,6 @@ void CheckpointFunction::RegisterFunction(BuiltinFunctions &set) { - #include namespace duckdb { @@ -201766,6 +203617,12 @@ void BaseCSVData::Finalize() { } } +string TransformNewLine(string new_line) { + new_line = StringUtil::Replace(new_line, "\\r", "\r"); + return StringUtil::Replace(new_line, "\\n", "\n"); + ; +} + static unique_ptr WriteCSVBind(ClientContext &context, CopyFunctionBindInput &input, const vector &names, const vector &sql_types) { auto bind_data = make_uniq(input.info.file_path, sql_types, names); @@ -201791,7 +203648,7 @@ static unique_ptr WriteCSVBind(ClientContext &context, CopyFunctio bind_data->requires_quotes[bind_data->options.dialect_options.state_machine_options.quote.GetValue()] = true; if (!bind_data->options.write_newline.empty()) { - bind_data->newline = bind_data->options.write_newline; + bind_data->newline = TransformNewLine(bind_data->options.write_newline); } return std::move(bind_data); } @@ -202451,6 +204308,11 @@ static unique_ptr RangeDateTimeBind(ClientContext &context, TableF auto result = make_uniq(); auto &inputs = input.inputs; D_ASSERT(inputs.size() == 3); + for (idx_t i = 0; i < inputs.size(); ++i) { + if (inputs[i].IsNull()) { + throw BinderException("RANGE with NULL argument is not supported"); + } + } result->start = inputs[0].GetValue(); result->end = inputs[1].GetValue(); result->increment = inputs[2].GetValue(); @@ -202787,8 +204649,6 @@ static void ReadCSVFunction(ClientContext &context, TableFunctionInput &data_p, break; } if (csv_local_state.csv_reader->FinishedIterator()) { - csv_local_state.csv_reader->csv_file_scan->error_handler->Insert( - csv_local_state.csv_reader->GetBoundaryIndex(), csv_local_state.csv_reader->GetLinesRead()); csv_local_state.csv_reader = csv_global_state.Next(); if (!csv_local_state.csv_reader) { csv_global_state.DecrementThread(); @@ -202846,6 +204706,9 @@ void ReadCSVTableFunction::ReadCSVAddNamedParameters(TableFunction &table_functi double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p, const GlobalTableFunctionState *global_state) { + if (!global_state) { + return 0; + } auto &bind_data = bind_data_p->Cast(); auto &data = global_state->Cast(); return data.GetProgress(bind_data); @@ -203026,7 +204889,7 @@ struct ReadFileGlobalState : public GlobalTableFunctionState { ReadFileGlobalState() : current_file_idx(0) { } - idx_t current_file_idx; + atomic current_file_idx; vector files; vector column_ids; bool requires_file_open = false; @@ -203460,7 +205323,7 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p, NewLineIdentifierToString(sniffer_options.dialect_options.state_machine_options.new_line.GetValue()); output.SetValue(3, 0, new_line_identifier); // 5. Skip Rows - output.SetValue(4, 0, Value::UINTEGER(sniffer_options.dialect_options.skip_rows.GetValue())); + output.SetValue(4, 0, Value::UINTEGER(NumericCast(sniffer_options.dialect_options.skip_rows.GetValue()))); // 6. Has Header auto has_header = Value::BOOLEAN(sniffer_options.dialect_options.header.GetValue()).ToString(); output.SetValue(5, 0, has_header); @@ -203967,7 +205830,11 @@ class ViewColumnHelper : public ColumnHelper { return true; } const Value ColumnComment(idx_t col) override { - return Value(); + if (entry.column_comments.empty()) { + return Value(); + } + D_ASSERT(entry.column_comments.size() == entry.types.size()); + return entry.column_comments[col]; } private: @@ -204006,7 +205873,7 @@ void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_co // column_name, VARCHAR output.SetValue(col++, index, Value(ColumnName(i))); // column_index, INTEGER - output.SetValue(col++, index, Value::INTEGER(i + 1)); + output.SetValue(col++, index, Value::INTEGER(UnsafeNumericCast(i + 1))); // comment, VARCHAR output.SetValue(col++, index, ColumnComment(i)); // internal, BOOLEAN @@ -205827,6 +207694,7 @@ struct DuckDBSecretsData : public GlobalTableFunctionState { DuckDBSecretsData() : offset(0) { } idx_t offset; + duckdb::vector secrets; }; struct DuckDBSecretsBindData : public FunctionData { @@ -205896,8 +207764,11 @@ void DuckDBSecretsFunction(ClientContext &context, TableFunctionInput &data_p, D auto &secret_manager = SecretManager::Get(context); auto transaction = CatalogTransaction::GetSystemCatalogTransaction(context); - auto secrets = secret_manager.AllSecrets(transaction); + if (data.secrets.empty()) { + data.secrets = secret_manager.AllSecrets(transaction); + } + auto &secrets = data.secrets; if (data.offset >= secrets.size()) { // finished returning values return; @@ -205947,6 +207818,7 @@ void DuckDBSecretsFun::RegisterFunction(BuiltinFunctions &set) { + namespace duckdb { struct DuckDBSequencesData : public GlobalTableFunctionState { @@ -206061,7 +207933,8 @@ void DuckDBSequencesFunction(ClientContext &context, TableFunctionInput &data_p, // cycle, BOOLEAN output.SetValue(col++, count, Value::BOOLEAN(seq_data.cycle)); // last_value, BIGINT - output.SetValue(col++, count, seq_data.usage_count == 0 ? Value() : Value::BOOLEAN(seq_data.last_value)); + output.SetValue(col++, count, + seq_data.usage_count == 0 ? Value() : Value::BOOLEAN(NumericCast(seq_data.last_value))); // sql, LogicalType::VARCHAR output.SetValue(col++, count, Value(seq.ToSQL())); @@ -206088,6 +207961,7 @@ struct DuckDBSettingValue { string value; string description; string input_type; + string scope; }; struct DuckDBSettingsData : public GlobalTableFunctionState { @@ -206112,6 +207986,9 @@ static unique_ptr DuckDBSettingsBind(ClientContext &context, Table names.emplace_back("input_type"); return_types.emplace_back(LogicalType::VARCHAR); + names.emplace_back("scope"); + return_types.emplace_back(LogicalType::VARCHAR); + return nullptr; } @@ -206124,24 +208001,30 @@ unique_ptr DuckDBSettingsInit(ClientContext &context, auto option = DBConfig::GetOptionByIndex(i); D_ASSERT(option); DuckDBSettingValue value; + auto scope = option->set_global ? SettingScope::GLOBAL : SettingScope::LOCAL; value.name = option->name; value.value = option->get_setting(context).ToString(); value.description = option->description; value.input_type = EnumUtil::ToString(option->parameter_type); + value.scope = EnumUtil::ToString(scope); result->settings.push_back(std::move(value)); } for (auto &ext_param : config.extension_parameters) { Value setting_val; string setting_str_val; - if (context.TryGetCurrentSetting(ext_param.first, setting_val)) { + auto scope = SettingScope::GLOBAL; + auto lookup_result = context.TryGetCurrentSetting(ext_param.first, setting_val); + if (lookup_result) { setting_str_val = setting_val.ToString(); + scope = lookup_result.GetScope(); } DuckDBSettingValue value; value.name = ext_param.first; value.value = std::move(setting_str_val); value.description = ext_param.second.description; value.input_type = ext_param.second.type.ToString(); + value.scope = EnumUtil::ToString(scope); result->settings.push_back(std::move(value)); } @@ -206169,6 +208052,8 @@ void DuckDBSettingsFunction(ClientContext &context, TableFunctionInput &data_p, output.SetValue(2, count, Value(entry.description)); // input_type, LogicalType::VARCHAR output.SetValue(3, count, Value(entry.input_type)); + // scope, LogicalType::VARCHAR + output.SetValue(4, count, Value(entry.scope)); count++; } output.SetCardinality(count); @@ -207663,6 +209548,70 @@ vector TestAllTypesFun::GetTestTypes(bool use_large_enum) { const Value &max = Value::UNION(members, 1, Value::SMALLINT(5)); result.emplace_back(union_type, "union", min, max); + // fixed int array + auto fixed_int_array_type = LogicalType::ARRAY(LogicalType::INTEGER, 3); + auto fixed_int_min_array_value = Value::ARRAY({Value(LogicalType::INTEGER), 2, 3}); + auto fixed_int_max_array_value = Value::ARRAY({4, 5, 6}); + result.emplace_back(fixed_int_array_type, "fixed_int_array", fixed_int_min_array_value, fixed_int_max_array_value); + + // fixed varchar array + auto fixed_varchar_array_type = LogicalType::ARRAY(LogicalType::VARCHAR, 3); + auto fixed_varchar_min_array_value = Value::ARRAY({Value("a"), Value(LogicalType::VARCHAR), Value("c")}); + auto fixed_varchar_max_array_value = Value::ARRAY({Value("d"), Value("e"), Value("f")}); + result.emplace_back(fixed_varchar_array_type, "fixed_varchar_array", fixed_varchar_min_array_value, + fixed_varchar_max_array_value); + + // fixed nested int array + auto fixed_nested_int_array_type = LogicalType::ARRAY(fixed_int_array_type, 3); + auto fixed_nested_int_min_array_value = + Value::ARRAY({fixed_int_min_array_value, Value(fixed_int_array_type), fixed_int_min_array_value}); + auto fixed_nested_int_max_array_value = + Value::ARRAY({fixed_int_max_array_value, fixed_int_min_array_value, fixed_int_max_array_value}); + result.emplace_back(fixed_nested_int_array_type, "fixed_nested_int_array", fixed_nested_int_min_array_value, + fixed_nested_int_max_array_value); + + // fixed nested varchar array + auto fixed_nested_varchar_array_type = LogicalType::ARRAY(fixed_varchar_array_type, 3); + auto fixed_nested_varchar_min_array_value = + Value::ARRAY({fixed_varchar_min_array_value, Value(fixed_varchar_array_type), fixed_varchar_min_array_value}); + auto fixed_nested_varchar_max_array_value = + Value::ARRAY({fixed_varchar_max_array_value, fixed_varchar_min_array_value, fixed_varchar_max_array_value}); + result.emplace_back(fixed_nested_varchar_array_type, "fixed_nested_varchar_array", + fixed_nested_varchar_min_array_value, fixed_nested_varchar_max_array_value); + + // fixed array of structs + auto fixed_struct_array_type = LogicalType::ARRAY(struct_type, 3); + auto fixed_struct_min_array_value = Value::ARRAY({min_struct_val, max_struct_val, min_struct_val}); + auto fixed_struct_max_array_value = Value::ARRAY({max_struct_val, min_struct_val, max_struct_val}); + result.emplace_back(fixed_struct_array_type, "fixed_struct_array", fixed_struct_min_array_value, + fixed_struct_max_array_value); + + // struct of fixed array + auto struct_of_fixed_array_type = + LogicalType::STRUCT({{"a", fixed_int_array_type}, {"b", fixed_varchar_array_type}}); + auto struct_of_fixed_array_min_value = + Value::STRUCT({{"a", fixed_int_min_array_value}, {"b", fixed_varchar_min_array_value}}); + auto struct_of_fixed_array_max_value = + Value::STRUCT({{"a", fixed_int_max_array_value}, {"b", fixed_varchar_max_array_value}}); + result.emplace_back(struct_of_fixed_array_type, "struct_of_fixed_array", struct_of_fixed_array_min_value, + struct_of_fixed_array_max_value); + + // fixed array of list of int + auto fixed_array_of_list_of_int_type = LogicalType::ARRAY(LogicalType::LIST(LogicalType::INTEGER), 3); + auto fixed_array_of_list_of_int_min_value = Value::ARRAY({empty_int_list, int_list, empty_int_list}); + auto fixed_array_of_list_of_int_max_value = Value::ARRAY({int_list, empty_int_list, int_list}); + result.emplace_back(fixed_array_of_list_of_int_type, "fixed_array_of_int_list", + fixed_array_of_list_of_int_min_value, fixed_array_of_list_of_int_max_value); + + // list of fixed array of int + auto list_of_fixed_array_of_int_type = LogicalType::LIST(fixed_int_array_type); + auto list_of_fixed_array_of_int_min_value = + Value::LIST({fixed_int_min_array_value, fixed_int_max_array_value, fixed_int_min_array_value}); + auto list_of_fixed_array_of_int_max_value = + Value::LIST({fixed_int_max_array_value, fixed_int_min_array_value, fixed_int_max_array_value}); + result.emplace_back(list_of_fixed_array_of_int_type, "list_of_fixed_int_array", + list_of_fixed_array_of_int_min_value, list_of_fixed_array_of_int_max_value); + return result; } @@ -209027,7 +210976,8 @@ void BaseAppender::AppendDecimalValueInternal(Vector &col, SRC input) { D_ASSERT(type.id() == LogicalTypeId::DECIMAL); auto width = DecimalType::GetWidth(type); auto scale = DecimalType::GetScale(type); - TryCastToDecimal::Operation(input, FlatVector::GetData(col)[chunk.size()], nullptr, width, + CastParameters parameters; + TryCastToDecimal::Operation(input, FlatVector::GetData(col)[chunk.size()], parameters, width, scale); return; } @@ -209367,8 +211317,14 @@ class DuckTransactionManager : public TransactionManager { return true; } +protected: + struct CheckpointDecision { + bool can_checkpoint; + string reason; + }; + private: - bool CanCheckpoint(optional_ptr current = nullptr); + CheckpointDecision CanCheckpoint(optional_ptr current = nullptr); //! Remove the given transaction from the list of active transactions void RemoveTransaction(DuckTransaction &transaction) noexcept; @@ -209391,6 +211347,10 @@ class DuckTransactionManager : public TransactionManager { mutex transaction_lock; bool thread_is_checkpointing; + +protected: + virtual void OnCommitCheckpointDecision(const CheckpointDecision &decision, DuckTransaction &transaction) { + } }; } // namespace duckdb @@ -209419,8 +211379,10 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, str : CatalogEntry(CatalogType::DATABASE_ENTRY, catalog_p, std::move(name_p)), db(db), parent_catalog(&catalog_p) { type = access_mode == AccessMode::READ_ONLY ? AttachedDatabaseType::READ_ONLY_DATABASE : AttachedDatabaseType::READ_WRITE_DATABASE; - storage = make_uniq(*this, std::move(file_path_p), access_mode == AccessMode::READ_ONLY); catalog = make_uniq(*this); + // do this after catalog to guarnatee we allow extension to instantionate DuckCatalog causing creation + // of the storage + storage = make_uniq(*this, std::move(file_path_p), access_mode == AccessMode::READ_ONLY); transaction_manager = make_uniq(*this); internal = true; } @@ -209436,6 +211398,10 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, Sto if (!catalog) { throw InternalException("AttachedDatabase - attach function did not return a catalog"); } + if (catalog->IsDuckCatalog()) { + // DuckCatalog, instantiate storage + storage = make_uniq(*this, info.path, access_mode == AccessMode::READ_ONLY); + } transaction_manager = storage_extension.create_transaction_manager(storage_extension.storage_info.get(), *this, *catalog); if (!transaction_manager) { @@ -209446,31 +211412,7 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, Sto } AttachedDatabase::~AttachedDatabase() { - D_ASSERT(catalog); - - if (!IsSystem() && !catalog->InMemory()) { - db.GetDatabaseManager().EraseDatabasePath(catalog->GetDBPath()); - } - - if (Exception::UncaughtException()) { - return; - } - if (!storage) { - return; - } - - // shutting down: attempt to checkpoint the database - // but only if we are not cleaning up as part of an exception unwind - try { - if (!storage->InMemory()) { - auto &config = DBConfig::GetConfig(db); - if (!config.options.checkpoint_on_shutdown) { - return; - } - storage->CreateCheckpoint(true); - } - } catch (...) { - } + Close(); } bool AttachedDatabase::IsSystem() const { @@ -209485,11 +211427,19 @@ bool AttachedDatabase::IsReadOnly() const { return type == AttachedDatabaseType::READ_ONLY_DATABASE; } +bool AttachedDatabase::NameIsReserved(const string &name) { + return name == DEFAULT_SCHEMA || name == TEMP_CATALOG; +} + string AttachedDatabase::ExtractDatabaseName(const string &dbpath, FileSystem &fs) { if (dbpath.empty() || dbpath == IN_MEMORY_PATH) { return "memory"; } - return fs.ExtractBaseName(dbpath); + auto name = fs.ExtractBaseName(dbpath); + if (NameIsReserved(name)) { + name += "_db"; + } + return name; } void AttachedDatabase::Initialize() { @@ -209530,6 +211480,38 @@ void AttachedDatabase::SetInitialDatabase() { is_initial_database = true; } +void AttachedDatabase::Close() { + D_ASSERT(catalog); + if (is_closed) { + return; + } + is_closed = true; + + if (!IsSystem() && !catalog->InMemory()) { + db.GetDatabaseManager().EraseDatabasePath(catalog->GetDBPath()); + } + + if (Exception::UncaughtException()) { + return; + } + if (!storage) { + return; + } + + // shutting down: attempt to checkpoint the database + // but only if we are not cleaning up as part of an exception unwind + try { + if (!storage->InMemory()) { + auto &config = DBConfig::GetConfig(db); + if (!config.options.checkpoint_on_shutdown) { + return; + } + storage->CreateCheckpoint(true); + } + } catch (...) { + } +} + } // namespace duckdb @@ -209826,7 +211808,7 @@ duckdb_state duckdb_append_varchar(duckdb_appender appender, const char *val) { } duckdb_state duckdb_append_varchar_length(duckdb_appender appender, const char *val, idx_t length) { - return duckdb_append_internal(appender, string_t(val, length)); + return duckdb_append_internal(appender, string_t(val, duckdb::UnsafeNumericCast(length))); } duckdb_state duckdb_append_blob(duckdb_appender appender, const void *data, idx_t length) { auto value = duckdb::Value::BLOB((duckdb::const_data_ptr_t)data, length); @@ -210345,19 +212327,21 @@ bool CastDecimalCInternal(duckdb_result *source, RESULT_TYPE &result, idx_t col, auto width = duckdb::DecimalType::GetWidth(source_type); auto scale = duckdb::DecimalType::GetScale(source_type); void *source_address = UnsafeFetchPtr(source, col, row); + + CastParameters parameters; switch (source_type.InternalType()) { case duckdb::PhysicalType::INT16: return duckdb::TryCastFromDecimal::Operation(UnsafeFetchFromPtr(source_address), - result, nullptr, width, scale); + result, parameters, width, scale); case duckdb::PhysicalType::INT32: return duckdb::TryCastFromDecimal::Operation(UnsafeFetchFromPtr(source_address), - result, nullptr, width, scale); + result, parameters, width, scale); case duckdb::PhysicalType::INT64: return duckdb::TryCastFromDecimal::Operation(UnsafeFetchFromPtr(source_address), - result, nullptr, width, scale); + result, parameters, width, scale); case duckdb::PhysicalType::INT128: return duckdb::TryCastFromDecimal::Operation( - UnsafeFetchFromPtr(source_address), result, nullptr, width, scale); + UnsafeFetchFromPtr(source_address), result, parameters, width, scale); default: throw duckdb::InternalException("Unimplemented internal type for decimal"); } @@ -210576,7 +212560,7 @@ duckdb_blob FetchDefaultValue::Operation() { template <> bool FromCBlobCastWrapper::Operation(duckdb_blob input, duckdb_string &result) { - string_t input_str(const_char_ptr_cast(input.data), input.size); + string_t input_str(const_char_ptr_cast(input.data), UnsafeNumericCast(input.size)); return ToCStringCastWrapper::template Operation(input_str, result); } @@ -210781,7 +212765,7 @@ void duckdb_vector_assign_string_element_len(duckdb_vector vector, idx_t index, } auto v = reinterpret_cast(vector); auto data = duckdb::FlatVector::GetData(*v); - data[index] = duckdb::StringVector::AddString(*v, str, str_len); + data[index] = duckdb::StringVector::AddStringOrBlob(*v, str, str_len); } duckdb_vector duckdb_list_vector_get_child(duckdb_vector vector) { @@ -210826,6 +212810,14 @@ duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index) return reinterpret_cast(duckdb::StructVector::GetEntries(*v)[index].get()); } +duckdb_vector duckdb_array_vector_get_child(duckdb_vector vector) { + if (!vector) { + return nullptr; + } + auto v = reinterpret_cast(vector); + return reinterpret_cast(&duckdb::ArrayVector::GetEntry(*v)); +} + bool duckdb_validity_row_is_valid(uint64_t *validity, idx_t row) { if (!validity) { return true; @@ -210865,6 +212857,7 @@ void duckdb_validity_set_row_valid(uint64_t *validity, idx_t row) { + using duckdb::Date; using duckdb::Time; using duckdb::Timestamp; @@ -210879,8 +212872,8 @@ duckdb_date_struct duckdb_from_date(duckdb_date date) { duckdb_date_struct result; result.year = year; - result.month = month; - result.day = day; + result.month = duckdb::UnsafeNumericCast(month); + result.day = duckdb::UnsafeNumericCast(day); return result; } @@ -210899,18 +212892,23 @@ duckdb_time_struct duckdb_from_time(duckdb_time time) { Time::Convert(dtime_t(time.micros), hour, minute, second, micros); duckdb_time_struct result; - result.hour = hour; - result.min = minute; - result.sec = second; + result.hour = duckdb::UnsafeNumericCast(hour); + result.min = duckdb::UnsafeNumericCast(minute); + result.sec = duckdb::UnsafeNumericCast(second); result.micros = micros; return result; } duckdb_time_tz_struct duckdb_from_time_tz(duckdb_time_tz input) { - duckdb::dtime_tz_t time(input.bits); duckdb_time_tz_struct result; - result.time.micros = time.time().micros; - result.offset = time.offset(); + duckdb_time time; + + duckdb::dtime_tz_t time_tz(input.bits); + + time.micros = time_tz.time().micros; + + result.time = duckdb_from_time(time); + result.offset = time_tz.offset(); return result; } @@ -211137,7 +213135,7 @@ duckdb_value duckdb_create_struct_value(duckdb_logical_type type, duckdb_value * } duckdb::Value *struct_value = new duckdb::Value; try { - *struct_value = duckdb::Value::STRUCT(ltype, unwrapped_values); + *struct_value = duckdb::Value::STRUCT(ltype, std::move(unwrapped_values)); } catch (...) { delete struct_value; return nullptr; @@ -211160,7 +213158,7 @@ duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *va } duckdb::Value *list_value = new duckdb::Value; try { - *list_value = duckdb::Value::LIST(ltype, unwrapped_values); + *list_value = duckdb::Value::LIST(ltype, std::move(unwrapped_values)); } catch (...) { delete list_value; return nullptr; @@ -211168,6 +213166,33 @@ duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *va return WrapValue(list_value); } +duckdb_value duckdb_create_array_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count) { + if (!type || !values) { + return nullptr; + } + if (value_count >= duckdb::ArrayType::MAX_ARRAY_SIZE) { + return nullptr; + } + auto <ype = UnwrapType(type); + duckdb::vector unwrapped_values; + + for (idx_t i = 0; i < value_count; i++) { + auto value = values[i]; + if (!value) { + return nullptr; + } + unwrapped_values.push_back(UnwrapValue(value)); + } + duckdb::Value *array_value = new duckdb::Value; + try { + *array_value = duckdb::Value::ARRAY(ltype, std::move(unwrapped_values)); + } catch (...) { + delete array_value; + return nullptr; + } + return WrapValue(array_value); +} + namespace duckdb { @@ -211295,6 +213320,8 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) { return DUCKDB_TYPE_UNION; case LogicalTypeId::UUID: return DUCKDB_TYPE_UUID; + case LogicalTypeId::ARRAY: + return DUCKDB_TYPE_ARRAY; default: // LCOV_EXCL_START D_ASSERT(0); return DUCKDB_TYPE_INVALID; @@ -211459,7 +213486,8 @@ namespace duckdb { template struct ToCDecimalCastWrapper { template - static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, std::string *error, uint8_t width, uint8_t scale) { + static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { throw NotImplementedException("Type not implemented for CDecimalCastWrapper"); } }; @@ -211468,10 +213496,12 @@ struct ToCDecimalCastWrapper { template <> struct ToCDecimalCastWrapper { template - static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, std::string *error, uint8_t width, uint8_t scale) { + static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { hugeint_t intermediate_result; - if (!TryCastToDecimal::Operation(input, intermediate_result, error, width, scale)) { + if (!TryCastToDecimal::Operation(input, intermediate_result, parameters, width, + scale)) { result = FetchDefaultValue::Operation(); return false; } @@ -211491,10 +213521,11 @@ struct ToCDecimalCastWrapper { template <> struct ToCDecimalCastWrapper { template - static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, std::string *error, uint8_t width, uint8_t scale) { + static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { int16_t intermediate_result; - if (!TryCastToDecimal::Operation(input, intermediate_result, error, width, scale)) { + if (!TryCastToDecimal::Operation(input, intermediate_result, parameters, width, scale)) { result = FetchDefaultValue::Operation(); return false; } @@ -211514,10 +213545,11 @@ struct ToCDecimalCastWrapper { template <> struct ToCDecimalCastWrapper { template - static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, std::string *error, uint8_t width, uint8_t scale) { + static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { int32_t intermediate_result; - if (!TryCastToDecimal::Operation(input, intermediate_result, error, width, scale)) { + if (!TryCastToDecimal::Operation(input, intermediate_result, parameters, width, scale)) { result = FetchDefaultValue::Operation(); return false; } @@ -211537,10 +213569,11 @@ struct ToCDecimalCastWrapper { template <> struct ToCDecimalCastWrapper { template - static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, std::string *error, uint8_t width, uint8_t scale) { + static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, CastParameters ¶meters, uint8_t width, + uint8_t scale) { int64_t intermediate_result; - if (!TryCastToDecimal::Operation(input, intermediate_result, error, width, scale)) { + if (!TryCastToDecimal::Operation(input, intermediate_result, parameters, width, scale)) { result = FetchDefaultValue::Operation(); return false; } @@ -211561,7 +213594,8 @@ template duckdb_decimal TryCastToDecimalCInternal(SOURCE_TYPE source, uint8_t width, uint8_t scale) { duckdb_decimal result; try { - if (!OP::template Operation(source, result, nullptr, width, scale)) { + CastParameters parameters; + if (!OP::template Operation(source, result, parameters, width, scale)) { return FetchDefaultValue::Operation(); } } catch (...) { @@ -211649,7 +213683,8 @@ double duckdb_decimal_to_double(duckdb_decimal val) { hugeint_t value; value.lower = val.value.lower; value.upper = val.value.upper; - duckdb::TryCastFromDecimal::Operation(value, result, nullptr, val.width, val.scale); + duckdb::CastParameters parameters; + duckdb::TryCastFromDecimal::Operation(value, result, parameters, val.width, val.scale); return result; } @@ -211689,6 +213724,18 @@ duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type) { return reinterpret_cast(ltype); } +duckdb_logical_type duckdb_create_array_type(duckdb_logical_type type, idx_t array_size) { + if (!type) { + return nullptr; + } + if (array_size >= duckdb::ArrayType::MAX_ARRAY_SIZE) { + return nullptr; + } + duckdb::LogicalType *ltype = new duckdb::LogicalType; + *ltype = duckdb::LogicalType::ARRAY(*reinterpret_cast(type), array_size); + return reinterpret_cast(ltype); +} + duckdb_logical_type duckdb_create_union_type(duckdb_logical_type *member_types_p, const char **member_names, idx_t member_count) { if (!member_types_p || !member_names) { @@ -211833,7 +213880,7 @@ uint32_t duckdb_enum_dictionary_size(duckdb_logical_type type) { return 0; } auto <ype = *(reinterpret_cast(type)); - return duckdb::EnumType::GetSize(ltype); + return duckdb::NumericCast(duckdb::EnumType::GetSize(ltype)); } char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t index) { @@ -211858,6 +213905,28 @@ duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type) { return reinterpret_cast(new duckdb::LogicalType(duckdb::ListType::GetChildType(ltype))); } +duckdb_logical_type duckdb_array_type_child_type(duckdb_logical_type type) { + if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ARRAY)) { + return nullptr; + } + auto <ype = *(reinterpret_cast(type)); + if (ltype.id() != duckdb::LogicalTypeId::ARRAY) { + return nullptr; + } + return reinterpret_cast(new duckdb::LogicalType(duckdb::ArrayType::GetChildType(ltype))); +} + +idx_t duckdb_array_type_array_size(duckdb_logical_type type) { + if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ARRAY)) { + return 0; + } + auto <ype = *(reinterpret_cast(type)); + if (ltype.id() != duckdb::LogicalTypeId::ARRAY) { + return 0; + } + return duckdb::ArrayType::GetSize(ltype); +} + duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type) { if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::MAP)) { return nullptr; @@ -212640,6 +214709,9 @@ struct CBlobConverter { struct CTimestampMsConverter : public CBaseConverter { template static DST Convert(SRC input) { + if (!Timestamp::IsFinite(input)) { + return input; + } return Timestamp::FromEpochMs(input.value); } }; @@ -212647,6 +214719,9 @@ struct CTimestampMsConverter : public CBaseConverter { struct CTimestampNsConverter : public CBaseConverter { template static DST Convert(SRC input) { + if (!Timestamp::IsFinite(input)) { + return input; + } return Timestamp::FromEpochNanoSeconds(input.value); } }; @@ -212654,6 +214729,9 @@ struct CTimestampNsConverter : public CBaseConverter { struct CTimestampSecConverter : public CBaseConverter { template static DST Convert(SRC input) { + if (!Timestamp::IsFinite(input)) { + return input; + } return Timestamp::FromEpochSeconds(input.value); } }; @@ -214140,8 +216218,8 @@ class ClientContextFileOpener : public FileOpener { explicit ClientContextFileOpener(ClientContext &context_p) : context(context_p) { } - bool TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) override; - bool TryGetCurrentSetting(const string &key, Value &result) override; + SettingLookupResult TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) override; + SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) override; ClientContext *TryGetClientContext() override { return &context; @@ -214182,78 +216260,6 @@ class ClientContextFileOpener : public FileOpener { -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/optimizer/rule.hpp -// -// -//===----------------------------------------------------------------------===// - - - - -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/optimizer/matcher/logical_operator_matcher.hpp -// -// -//===----------------------------------------------------------------------===// - - - - - -namespace duckdb { - -//! The LogicalOperatorMatcher class contains a set of matchers that can be used to match LogicalOperators -class LogicalOperatorMatcher { -public: - virtual ~LogicalOperatorMatcher() { - } - - virtual bool Match(LogicalOperatorType type) = 0; -}; - -//! The SpecificLogicalTypeMatcher class matches only a single specified LogicalOperatorType -class SpecificLogicalTypeMatcher : public LogicalOperatorMatcher { -public: - explicit SpecificLogicalTypeMatcher(LogicalOperatorType type) : type(type) { - } - - bool Match(LogicalOperatorType type) override { - return type == this->type; - } - -private: - LogicalOperatorType type; -}; - -} // namespace duckdb - - -namespace duckdb { -class ExpressionRewriter; - -class Rule { -public: - explicit Rule(ExpressionRewriter &rewriter) : rewriter(rewriter) { - } - virtual ~Rule() { - } - - //! The expression rewriter this rule belongs to - ExpressionRewriter &rewriter; - //! The expression matcher of the rule - unique_ptr root; - - ClientContext &GetContext() const; - virtual unique_ptr Apply(LogicalOperator &op, vector> &bindings, - bool &fixed_point, bool is_root) = 0; -}; - -} // namespace duckdb @@ -214664,6 +216670,22 @@ struct DebugClientContextState : public ClientContextState { } active_transaction = false; } +#ifdef DUCKDB_DEBUG_REBIND + RebindQueryInfo OnPlanningError(ClientContext &context, SQLStatement &statement, ErrorData &error) override { + return RebindQueryInfo::ATTEMPT_TO_REBIND; + } + RebindQueryInfo OnFinalizePrepare(ClientContext &context, PreparedStatementData &prepared, + PreparedStatementMode mode) override { + if (mode == PreparedStatementMode::PREPARE_AND_EXECUTE) { + return RebindQueryInfo::ATTEMPT_TO_REBIND; + } + return RebindQueryInfo::DO_NOT_REBIND; + } + RebindQueryInfo OnExecutePrepared(ClientContext &context, PreparedStatementData &prepared_statement, + RebindQueryInfo current_rebind) override { + return RebindQueryInfo::ATTEMPT_TO_REBIND; + } +#endif }; #endif @@ -214840,8 +216862,9 @@ static bool IsExplainAnalyze(SQLStatement *statement) { } shared_ptr -ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &query, unique_ptr statement, - optional_ptr> values) { +ClientContext::CreatePreparedStatementInternal(ClientContextLock &lock, const string &query, + unique_ptr statement, + optional_ptr> values) { StatementType statement_type = statement->type; auto result = make_shared(statement_type); @@ -214867,7 +216890,6 @@ ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &qu result->types = planner.types; result->value_map = std::move(planner.value_map); result->catalog_version = MetaTransaction::Get(*this).catalog_version; - if (!planner.properties.bound_all_parameters) { return result; } @@ -214899,15 +216921,85 @@ ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &qu return result; } +shared_ptr +ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &query, unique_ptr statement, + optional_ptr> values, PreparedStatementMode mode) { + // check if any client context state could request a rebind + bool can_request_rebind = false; + for (auto const &s : registered_state) { + if (s.second->CanRequestRebind()) { + can_request_rebind = true; + break; + } + } + if (can_request_rebind) { + bool rebind = false; + // if any registered state can request a rebind we do the binding on a copy first + shared_ptr result; + try { + result = CreatePreparedStatementInternal(lock, query, statement->Copy(), values); + } catch (std::exception &ex) { + ErrorData error(ex); + // check if any registered client context state wants to try a rebind + for (auto const &s : registered_state) { + auto info = s.second->OnPlanningError(*this, *statement, error); + if (info == RebindQueryInfo::ATTEMPT_TO_REBIND) { + rebind = true; + } + } + if (!rebind) { + throw; + } + } + if (result) { + D_ASSERT(!rebind); + for (auto const &s : registered_state) { + auto info = s.second->OnFinalizePrepare(*this, *result, mode); + if (info == RebindQueryInfo::ATTEMPT_TO_REBIND) { + rebind = true; + } + } + } + if (!rebind) { + return result; + } + // an extension wants to do a rebind - do it once + } + + return CreatePreparedStatementInternal(lock, query, std::move(statement), values); +} + QueryProgress ClientContext::GetQueryProgress() { return query_progress; } -unique_ptr ClientContext::PendingPreparedStatement(ClientContextLock &lock, - shared_ptr statement_p, - const PendingQueryParameters ¶meters) { - D_ASSERT(active_query); - auto &statement = *statement_p; +void BindPreparedStatementParameters(PreparedStatementData &statement, const PendingQueryParameters ¶meters) { + case_insensitive_map_t owned_values; + if (parameters.parameters) { + auto ¶ms = *parameters.parameters; + for (auto &val : params) { + owned_values.emplace(val); + } + } + statement.Bind(std::move(owned_values)); +} + +void ClientContext::RebindPreparedStatement(ClientContextLock &lock, const string &query, + shared_ptr &prepared, + const PendingQueryParameters ¶meters) { + if (!prepared->unbound_statement) { + throw InternalException("ClientContext::RebindPreparedStatement called but PreparedStatementData did not have " + "an unbound statement so rebinding cannot be done"); + } + // catalog was modified: rebind the statement before execution + auto new_prepared = + CreatePreparedStatement(lock, query, prepared->unbound_statement->Copy(), parameters.parameters); + D_ASSERT(new_prepared->properties.bound_all_parameters); + prepared = std::move(new_prepared); + prepared->properties.bound_all_parameters = false; +} + +void ClientContext::CheckIfPreparedStatementIsExecutable(PreparedStatementData &statement) { if (ValidChecker::IsInvalidated(ActiveTransaction()) && statement.properties.requires_valid_transaction) { throw ErrorManager::InvalidatedTransaction(*this); } @@ -214925,16 +217017,15 @@ unique_ptr ClientContext::PendingPreparedStatement(ClientCon } meta_transaction.ModifyDatabase(*entry); } +} - // bind the bound values before execution - case_insensitive_map_t owned_values; - if (parameters.parameters) { - auto ¶ms = *parameters.parameters; - for (auto &val : params) { - owned_values.emplace(val); - } - } - statement.Bind(std::move(owned_values)); +unique_ptr +ClientContext::PendingPreparedStatementInternal(ClientContextLock &lock, shared_ptr statement_p, + const PendingQueryParameters ¶meters) { + D_ASSERT(active_query); + auto &statement = *statement_p; + + BindPreparedStatementParameters(statement, parameters); active_query->executor = make_uniq(*this); auto &executor = *active_query->executor; @@ -214972,6 +217063,27 @@ unique_ptr ClientContext::PendingPreparedStatement(ClientCon return pending_result; } +unique_ptr ClientContext::PendingPreparedStatement(ClientContextLock &lock, const string &query, + shared_ptr prepared, + const PendingQueryParameters ¶meters) { + CheckIfPreparedStatementIsExecutable(*prepared); + + RebindQueryInfo rebind = RebindQueryInfo::DO_NOT_REBIND; + if (prepared->RequireRebind(*this, parameters.parameters)) { + rebind = RebindQueryInfo::ATTEMPT_TO_REBIND; + } + for (auto const &s : registered_state) { + auto new_rebind = s.second->OnExecutePrepared(*this, *prepared, rebind); + if (new_rebind == RebindQueryInfo::ATTEMPT_TO_REBIND) { + rebind = RebindQueryInfo::ATTEMPT_TO_REBIND; + } + } + if (rebind == RebindQueryInfo::ATTEMPT_TO_REBIND) { + RebindPreparedStatement(lock, query, prepared, parameters); + } + return PendingPreparedStatementInternal(lock, prepared, parameters); +} + PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &lock, BaseQueryResult &result, bool dry_run) { D_ASSERT(active_query); @@ -214995,7 +217107,7 @@ PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &loc invalidate_transaction = true; } else { // Interrupted by an exception caused in a worker thread - auto error = executor.GetError(); + error = executor.GetError(); invalidate_transaction = Exception::InvalidatesTransaction(error.Type()); result.SetError(error); } @@ -215006,6 +217118,7 @@ PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &loc auto &db_instance = DatabaseInstance::GetDatabase(*this); ValidChecker::Invalidate(db_instance, error.RawMessage()); } + ProcessError(error, active_query->query); result.SetError(std::move(error)); } catch (...) { // LCOV_EXCL_START result.SetError(ErrorData("Unhandled exception in ExecuteTaskInternal")); @@ -215158,7 +217271,8 @@ unique_ptr ClientContext::PendingStatementInternal(ClientCon unique_ptr statement, const PendingQueryParameters ¶meters) { // prepare the query for execution - auto prepared = CreatePreparedStatement(lock, query, std::move(statement), parameters.parameters); + auto prepared = CreatePreparedStatement(lock, query, std::move(statement), parameters.parameters, + PreparedStatementMode::PREPARE_AND_EXECUTE); idx_t parameter_count = !parameters.parameters ? 0 : parameters.parameters->size(); if (prepared->properties.parameter_count > 0 && parameter_count == 0) { string error_message = StringUtil::Format("Expected %lld parameters, but none were supplied", @@ -215169,7 +217283,8 @@ unique_ptr ClientContext::PendingStatementInternal(ClientCon return ErrorResult(ErrorData("Not all parameters were bound"), query); } // execute the prepared statement - return PendingPreparedStatement(lock, std::move(prepared), parameters); + CheckIfPreparedStatementIsExecutable(*prepared); + return PendingPreparedStatementInternal(lock, std::move(prepared), parameters); } unique_ptr ClientContext::RunStatementInternal(ClientContextLock &lock, const string &query, @@ -215276,16 +217391,7 @@ unique_ptr ClientContext::PendingStatementOrPreparedStatemen if (statement) { pending = PendingStatementInternal(lock, query, std::move(statement), parameters); } else { - if (prepared->RequireRebind(*this, parameters.parameters)) { - // catalog was modified: rebind the statement before execution - auto new_prepared = - CreatePreparedStatement(lock, query, prepared->unbound_statement->Copy(), parameters.parameters); - D_ASSERT(new_prepared->properties.bound_all_parameters); - new_prepared->unbound_statement = std::move(prepared->unbound_statement); - prepared = std::move(new_prepared); - prepared->properties.bound_all_parameters = false; - } - pending = PendingPreparedStatement(lock, prepared, parameters); + pending = PendingPreparedStatement(lock, query, prepared, parameters); } } catch (std::exception &ex) { ErrorData error(ex); @@ -215683,13 +217789,13 @@ unique_ptr ClientContext::Execute(const shared_ptr &relat return ErrorResult(ErrorData(err_str)); } -bool ClientContext::TryGetCurrentSetting(const std::string &key, Value &result) { +SettingLookupResult ClientContext::TryGetCurrentSetting(const std::string &key, Value &result) { // first check the built-in settings auto &db_config = DBConfig::GetConfig(*this); auto option = db_config.GetOptionByName(key); if (option) { result = option->get_setting(*this); - return true; + return SettingLookupResult(SettingScope::LOCAL); } // check the client session values @@ -215699,7 +217805,7 @@ bool ClientContext::TryGetCurrentSetting(const std::string &key, Value &result) bool found_session_value = session_value != session_config_map.end(); if (found_session_value) { result = session_value->second; - return true; + return SettingLookupResult(SettingScope::LOCAL); } // finally check the global session values return db->TryGetCurrentSetting(key, result); @@ -215748,12 +217854,12 @@ bool ClientContext::ExecutionIsFinished() { namespace duckdb { -bool ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result) { +SettingLookupResult ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result) { return context.TryGetCurrentSetting(key, result); } // LCOV_EXCL_START -bool ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &) { +SettingLookupResult ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &) { return context.TryGetCurrentSetting(key, result); } @@ -215764,21 +217870,22 @@ ClientContext *FileOpener::TryGetClientContext(FileOpener *opener) { return opener->TryGetClientContext(); } -bool FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result) { +SettingLookupResult FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result) { if (!opener) { - return false; + return SettingLookupResult(); } return opener->TryGetCurrentSetting(key, result); } -bool FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result, FileOpenerInfo &info) { +SettingLookupResult FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result, + FileOpenerInfo &info) { if (!opener) { - return false; + return SettingLookupResult(); } return opener->TryGetCurrentSetting(key, result, info); } -bool FileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) { +SettingLookupResult FileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) { return this->TryGetCurrentSetting(key, result); } // LCOV_EXCL_STOP @@ -216203,6 +218310,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting DUCKDB_GLOBAL(EnableExternalAccessSetting), DUCKDB_GLOBAL(EnableFSSTVectors), DUCKDB_GLOBAL(AllowUnsignedExtensionsSetting), + DUCKDB_GLOBAL(AllowUnredactedSecretsSetting), DUCKDB_GLOBAL(CustomExtensionRepository), DUCKDB_GLOBAL(AutoloadExtensionRepository), DUCKDB_GLOBAL(AutoinstallKnownExtensions), @@ -216254,6 +218362,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting DUCKDB_GLOBAL(FlushAllocatorSetting), DUCKDB_GLOBAL(DuckDBApiSetting), DUCKDB_GLOBAL(CustomUserAgentSetting), + DUCKDB_LOCAL(PartitionedWriteFlushThreshold), FINAL_SETTING}; vector DBConfig::GetOptions() { @@ -216717,6 +218826,8 @@ class TableFunctionRelation : public Relation { TableFunctionRelation(const std::shared_ptr &context, string name, vector parameters, shared_ptr input_relation_p = nullptr, bool auto_init = true); + ~TableFunctionRelation() override { + } string name; vector parameters; @@ -217177,6 +219288,40 @@ bool Connection::HasActiveTransaction() { +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/planner/extension_callback.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + +namespace duckdb { +class DatabaseInstance; + +class ExtensionCallback { +public: + virtual ~ExtensionCallback() { + } + + //! Called when a new connection is opened + virtual void OnConnectionOpened(ClientContext &context) { + } + //! Called when a connection is closed + virtual void OnConnectionClosed(ClientContext &context) { + } + //! Called after an extension is finished loading + virtual void OnExtensionLoaded(DatabaseInstance &db, const string &name) { + } +}; + +} // namespace duckdb + + namespace duckdb { ConnectionManager::ConnectionManager() : is_locking(false) { @@ -217184,11 +219329,17 @@ ConnectionManager::ConnectionManager() : is_locking(false) { void ConnectionManager::AddConnection(ClientContext &context) { lock_guard lock(connections_lock); + for (auto &callback : DBConfig::GetConfig(context).extension_callbacks) { + callback->OnConnectionOpened(context); + } connections.insert(make_pair(&context, weak_ptr(context.shared_from_this()))); } void ConnectionManager::RemoveConnection(ClientContext &context) { lock_guard lock(connections_lock); + for (auto &callback : DBConfig::GetConfig(context).extension_callbacks) { + callback->OnConnectionClosed(context); + } connections.erase(&context); } @@ -217245,32 +219396,6 @@ void ConnectionManager::LockClients(vector &client_locks, Cli -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/planner/extension_callback.hpp -// -// -//===----------------------------------------------------------------------===// - - - - - -namespace duckdb { -class DatabaseInstance; - -class ExtensionCallback { -public: - virtual ~ExtensionCallback() { - } - - //! Called after an extension is finished loading - virtual void OnExtensionLoaded(DatabaseInstance &db, const string &name) { - } -}; - -} // namespace duckdb //===----------------------------------------------------------------------===// @@ -217315,6 +219440,9 @@ class StandardBufferManager : public BufferManager { public: static unique_ptr CreateBufferManager(DatabaseInstance &db, string temp_directory); + static unique_ptr ReadTemporaryBufferInternal(BufferManager &buffer_manager, FileHandle &handle, + idx_t position, idx_t size, + unique_ptr reusable_buffer); //! Registers an in-memory buffer that cannot be unloaded until it is destroyed //! This buffer can be small (smaller than BLOCK_SIZE) //! Unpin and pin are nops on this block of memory @@ -217467,7 +219595,16 @@ DatabaseInstance::DatabaseInstance() { } DatabaseInstance::~DatabaseInstance() { - GetDatabaseManager().ResetDatabases(); + // destroy all attached databases + GetDatabaseManager().ResetDatabases(scheduler); + // destroy child elements + connection_manager.reset(); + object_cache.reset(); + scheduler.reset(); + db_manager.reset(); + buffer_manager.reset(); + // finally, flush allocations + Allocator::FlushAll(); } BufferManager &BufferManager::GetBufferManager(DatabaseInstance &db) { @@ -217808,7 +219945,7 @@ void DatabaseInstance::SetExtensionLoaded(const std::string &name) { } } -bool DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &result) { +SettingLookupResult DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &result) { // check the session values auto &db_config = DBConfig::GetConfig(*this); const auto &global_config_map = db_config.options.set_variables; @@ -217816,10 +219953,10 @@ bool DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &resul auto global_value = global_config_map.find(key); bool found_global_value = global_value != global_config_map.end(); if (!found_global_value) { - return false; + return SettingLookupResult(); } result = global_value->second; - return true; + return SettingLookupResult(SettingScope::GLOBAL); } ValidChecker &DatabaseInstance::GetValidChecker() { @@ -217869,6 +220006,9 @@ optional_ptr DatabaseManager::GetDatabase(ClientContext &conte optional_ptr DatabaseManager::AttachDatabase(ClientContext &context, const AttachInfo &info, const string &db_type, AccessMode access_mode) { + if (AttachedDatabase::NameIsReserved(info.name)) { + throw BinderException("Attached database name \"%s\" cannot be used because it is a reserved name", info.name); + } // now create the attached database auto &db = DatabaseInstance::GetDatabase(context); auto attached_db = db.CreateAttachedDatabase(context, info, db_type, access_mode); @@ -218038,7 +220178,13 @@ vector> DatabaseManager::GetDatabases(ClientContext return result; } -void DatabaseManager::ResetDatabases() { +void DatabaseManager::ResetDatabases(unique_ptr &scheduler) { + vector> result; + databases->Scan([&](CatalogEntry &entry) { result.push_back(entry.Cast()); }); + for (auto &database : result) { + database.get().Close(); + } + scheduler.reset(); databases.reset(); } @@ -218463,7 +220609,6 @@ static DefaultExtension internal_extensions[] = { {"arrow", "A zero-copy data integration between Apache Arrow and DuckDB", false}, {"azure", "Adds a filesystem abstraction for Azure blob storage to DuckDB", false}, {"iceberg", "Adds support for Apache Iceberg", false}, - {"visualizer", "Creates an HTML-based visualization of the query plan", false}, {nullptr, nullptr, false}}; idx_t ExtensionHelper::DefaultExtensionCount() { @@ -218512,19 +220657,23 @@ bool ExtensionHelper::CanAutoloadExtension(const string &ext_name) { string ExtensionHelper::AddExtensionInstallHintToErrorMsg(ClientContext &context, const string &base_error, const string &extension_name) { - auto &dbconfig = DBConfig::GetConfig(context); + + return AddExtensionInstallHintToErrorMsg(DBConfig::GetConfig(context), base_error, extension_name); +} +string ExtensionHelper::AddExtensionInstallHintToErrorMsg(DBConfig &config, const string &base_error, + const string &extension_name) { string install_hint; if (!ExtensionHelper::CanAutoloadExtension(extension_name)) { install_hint = "Please try installing and loading the " + extension_name + " extension:\nINSTALL " + extension_name + ";\nLOAD " + extension_name + ";\n\n"; - } else if (!dbconfig.options.autoload_known_extensions) { + } else if (!config.options.autoload_known_extensions) { install_hint = "Please try installing and loading the " + extension_name + " extension by running:\nINSTALL " + extension_name + ";\nLOAD " + extension_name + ";\n\nAlternatively, consider enabling auto-install " "and auto-load by running:\nSET autoinstall_known_extensions=1;\nSET autoload_known_extensions=1;"; - } else if (!dbconfig.options.autoinstall_known_extensions) { + } else if (!config.options.autoinstall_known_extensions) { install_hint = "Please try installing the " + extension_name + " extension by running:\nINSTALL " + extension_name + ";\n\nAlternatively, consider enabling autoinstall by running:\nSET autoinstall_known_extensions=1;"; @@ -218587,7 +220736,7 @@ void ExtensionHelper::LoadAllExtensions(DuckDB &db) { // The in-tree extensions that we check. Non-cmake builds are currently limited to these for static linking // TODO: rewrite package_build.py to allow also loading out-of-tree extensions in non-cmake builds, after that // these can be removed - unordered_set extensions {"parquet", "icu", "tpch", "tpcds", "fts", "httpfs", "visualizer", + unordered_set extensions {"parquet", "icu", "tpch", "tpcds", "fts", "httpfs", "json", "excel", "sqlsmith", "inet", "jemalloc", "autocomplete"}; for (auto &ext : extensions) { LoadExtensionInternal(db, ext, true); @@ -227348,7 +229497,7 @@ string ExtensionHelper::ExtensionUrlTemplate(optional_ptr db_con string versioned_path = "/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension"; #ifdef WASM_LOADABLE_EXTENSIONS string default_endpoint = "https://extensions.duckdb.org"; - versioned_path = "/duckdb-wasm" + versioned_path + ".wasm"; + versioned_path = versioned_path + ".wasm"; #else string default_endpoint = "http://extensions.duckdb.org"; versioned_path = versioned_path + ".gz"; @@ -228457,6 +230606,8 @@ unique_ptr PreparedStatement::PendingQuery(case_insensitive_ + + namespace duckdb { PreparedStatementData::PreparedStatementData(StatementType type) : statement_type(type) { @@ -228473,12 +230624,19 @@ void PreparedStatementData::CheckParameterCount(idx_t parameter_count) { } } +void StartTransactionInCatalog(ClientContext &context, const string &catalog_name) { + auto database = DatabaseManager::Get(context).GetDatabase(context, catalog_name); + if (!database) { + throw BinderException("Prepared statement requires database %s but it was not attached", catalog_name); + } + Transaction::Get(context, *database); +} + bool PreparedStatementData::RequireRebind(ClientContext &context, optional_ptr> values) { idx_t count = values ? values->size() : 0; CheckParameterCount(count); if (!unbound_statement) { - // no unbound statement!? cannot rebind? - return false; + throw InternalException("Prepared statement without unbound statement"); } if (properties.always_require_rebind) { // this statement must always be re-bound @@ -228488,10 +230646,6 @@ bool PreparedStatementData::RequireRebind(ClientContext &context, optional_ptrfind(identifier); @@ -228502,6 +230656,18 @@ bool PreparedStatementData::RequireRebind(ClientContext &context, optional_ptr #include @@ -228898,20 +231065,20 @@ static string DrawPadded(const string &str, idx_t width) { return str.substr(0, width); } else { width -= str.size(); - int half_spaces = width / 2; - int extra_left_space = width % 2 != 0 ? 1 : 0; + auto half_spaces = width / 2; + auto extra_left_space = width % 2 != 0 ? 1 : 0; return string(half_spaces + extra_left_space, ' ') + str + string(half_spaces, ' '); } } static string RenderTitleCase(string str) { str = StringUtil::Lower(str); - str[0] = toupper(str[0]); + str[0] = NumericCast(toupper(str[0])); for (idx_t i = 0; i < str.size(); i++) { if (str[i] == '_') { str[i] = ' '; if (i + 1 < str.size()) { - str[i + 1] = toupper(str[i + 1]); + str[i + 1] = NumericCast(toupper(str[i + 1])); } } } @@ -229079,8 +231246,8 @@ static void PrintRow(std::ostream &ss, const string &annotation, int id, const s static void ExtractFunctions(std::ostream &ss, ExpressionInfo &info, int &fun_id, int depth) { if (info.hasfunction) { double time = info.sample_tuples_count == 0 ? 0 : int(info.function_time) / double(info.sample_tuples_count); - PrintRow(ss, "Function", fun_id++, info.function_name, time, info.sample_tuples_count, info.tuples_count, "", - depth); + PrintRow(ss, "Function", fun_id++, info.function_name, time, NumericCast(info.sample_tuples_count), + NumericCast(info.tuples_count), "", NumericCast(depth)); } if (info.children.empty()) { return; @@ -229111,7 +231278,8 @@ static void ToJSONRecursive(QueryProfiler::TreeNode &node, std::ostream &ss, int ? 0 : double(expr_timer->time) / double(expr_timer->sample_tuples_count); PrintRow(ss, "ExpressionRoot", expression_counter++, expr_timer->name, time, - expr_timer->sample_tuples_count, expr_timer->tuples_count, expr_timer->extra_info, depth + 1); + NumericCast(expr_timer->sample_tuples_count), NumericCast(expr_timer->tuples_count), + expr_timer->extra_info, depth + 1); // Extract all functions inside the tree ExtractFunctions(ss, *expr_timer->root, function_counter, depth + 1); } @@ -230998,7 +233166,9 @@ ReadCSVRelation::ReadCSVRelation(const std::shared_ptr &context, InitializeAlias(input); auto file_list = CreateValueFromFileList(input); - auto files = MultiFileReader::GetFileList(*context, file_list, "CSV"); + + vector files; + context->RunFunctionInTransaction([&]() { files = MultiFileReader::GetFileList(*context, file_list, "CSV"); }); D_ASSERT(!files.empty()); auto &file_name = files[0]; @@ -231012,14 +233182,17 @@ ReadCSVRelation::ReadCSVRelation(const std::shared_ptr &context, // Run the auto-detect, populating the options with the detected settings - auto buffer_manager = make_shared(*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]); - } + shared_ptr buffer_manager; + context->RunFunctionInTransaction([&]() { + buffer_manager = make_shared(*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]); + } + }); // 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 @@ -231633,6 +233806,7 @@ ValueRelation::ValueRelation(const std::shared_ptr &context, cons } this->expressions.push_back(std::move(expressions)); } + QueryResult::DeduplicateColumns(names); context->TryBindRelation(*this, this->columns); } @@ -231640,6 +233814,7 @@ ValueRelation::ValueRelation(const std::shared_ptr &context, cons vector names_p, string alias_p) : Relation(context, RelationType::VALUE_LIST_RELATION), names(std::move(names_p)), alias(std::move(alias_p)) { this->expressions = Parser::ParseValuesList(values_list, context->GetParserOptions()); + QueryResult::DeduplicateColumns(names); context->TryBindRelation(*this, this->columns); } @@ -232304,7 +234479,7 @@ int64_t BaseSecret::MatchScore(const string &path) const { continue; } if (StringUtil::StartsWith(path, prefix)) { - longest_match = MaxValue(prefix.length(), longest_match); + longest_match = MaxValue(prefix.length(), longest_match); } } return longest_match; @@ -232647,8 +234822,7 @@ unique_ptr SecretManager::CreateSecret(ClientContext &context, cons // Lookup function auto function_lookup = LookupFunctionInternal(function_input.type, function_input.provider); if (!function_lookup) { - throw InvalidInputException("Could not find CreateSecretFunction for type: '%s' and provider: '%s'", info.type, - info.provider); + ThrowProviderNotFoundError(info.type, info.provider); } // Call the function @@ -232682,8 +234856,7 @@ BoundStatement SecretManager::BindCreateSecret(CatalogTransaction transaction, C auto function = LookupFunctionInternal(type, provider); if (!function) { - throw BinderException("Could not find create secret function for secret type '%s' with %sprovider '%s'", type, - default_string, provider); + ThrowProviderNotFoundError(info.type, info.provider, default_provider); } auto bound_info = info; @@ -232725,7 +234898,7 @@ SecretMatch SecretManager::LookupSecret(CatalogTransaction transaction, const st if (!storage_ref.get().IncludeInLookups()) { continue; } - auto match = storage_ref.get().LookupSecret(path, type, &transaction); + auto match = storage_ref.get().LookupSecret(path, StringUtil::Lower(type), &transaction); if (match.HasMatch() && match.score > best_match_score) { best_match = std::move(match.secret_entry); best_match_score = match.score; @@ -232850,7 +235023,7 @@ SecretType SecretManager::LookupTypeInternal(const string &type) { return lookup->second; } - throw InvalidInputException("Secret type '%s' not found", type); + ThrowTypeNotFoundError(type); } vector SecretManager::AllSecrets(CatalogTransaction transaction) { @@ -232940,11 +235113,39 @@ void SecretManager::InitializeSecrets(CatalogTransaction transaction) { } void SecretManager::AutoloadExtensionForType(const string &type) { - ExtensionHelper::TryAutoloadFromEntry(*db, type, EXTENSION_SECRET_TYPES); + ExtensionHelper::TryAutoloadFromEntry(*db, StringUtil::Lower(type), EXTENSION_SECRET_TYPES); +} + +void SecretManager::ThrowTypeNotFoundError(const string &type) { + auto entry = ExtensionHelper::FindExtensionInEntries(StringUtil::Lower(type), EXTENSION_SECRET_TYPES); + if (!entry.empty() && db) { + auto error_message = "Secret type '" + type + "' does not exist, but it exists in the " + entry + " extension."; + error_message = + ExtensionHelper::AddExtensionInstallHintToErrorMsg(DBConfig::GetConfig(*db), error_message, entry); + + throw InvalidInputException(error_message); + } + throw InvalidInputException("Secret type '%s' not found", type); } void SecretManager::AutoloadExtensionForFunction(const string &type, const string &provider) { - ExtensionHelper::TryAutoloadFromEntry(*db, type + "/" + provider, EXTENSION_SECRET_PROVIDERS); + ExtensionHelper::TryAutoloadFromEntry(*db, StringUtil::Lower(type) + "/" + StringUtil::Lower(provider), + EXTENSION_SECRET_PROVIDERS); +} + +void SecretManager::ThrowProviderNotFoundError(const string &type, const string &provider, bool was_default) { + auto entry = ExtensionHelper::FindExtensionInEntries(StringUtil::Lower(type) + "/" + StringUtil::Lower(provider), + EXTENSION_SECRET_PROVIDERS); + if (!entry.empty() && db) { + string error_message = was_default ? "Default secret provider" : "Secret provider"; + error_message += + " '" + provider + "' for type '" + type + "' does not exist, but it exists in the " + entry + " extension."; + error_message = + ExtensionHelper::AddExtensionInstallHintToErrorMsg(DBConfig::GetConfig(*db), error_message, entry); + + throw InvalidInputException(error_message); + } + throw InvalidInputException("Secret provider '%s' not found for type '%s'", provider, type); } optional_ptr SecretManager::GetSecretStorage(const string &name) { @@ -232991,6 +235192,13 @@ unique_ptr DefaultSecretGenerator::CreateDefaultEntry(ClientContex // Note each file should contain 1 secret try { auto file_reader = BufferedFileReader(fs, secret_path.c_str()); + + if (!LocalFileSystem::IsPrivateFile(secret_path, nullptr)) { + throw IOException( + "The secret file '%s' has incorrect permissions! Please set correct permissions or remove file", + secret_path); + } + if (!file_reader.Finished()) { BinaryDeserializer deserializer(file_reader); @@ -233162,7 +235370,7 @@ SecretMatch CatalogSetSecretStorage::LookupSecret(const string &path, const stri const std::function callback = [&](CatalogEntry &entry) { auto &cast_entry = entry.Cast(); - if (cast_entry.secret->secret->GetType() == type) { + if (StringUtil::CIEquals(cast_entry.secret->secret->GetType(), type)) { best_match = SelectBestMatch(*cast_entry.secret, path, best_match); } }; @@ -233261,7 +235469,13 @@ void LocalFileSecretStorage::WriteSecret(const BaseSecret &secret, OnCreateConfl fs.RemoveFile(file_path); } - auto file_writer = BufferedFileWriter(fs, file_path); + auto open_flags = FileFlags::FILE_FLAGS_WRITE; + // Ensure we are writing to a private file with 600 permission + open_flags |= FileFlags::FILE_FLAGS_PRIVATE; + // Ensure we overwrite anything that may have been placed there since our delete above + open_flags |= FileFlags::FILE_FLAGS_FILE_CREATE_NEW; + + auto file_writer = BufferedFileWriter(fs, file_path, open_flags); auto serializer = BinarySerializer(file_writer); serializer.Begin(); @@ -233356,7 +235570,8 @@ Value AccessModeSetting::GetSetting(ClientContext &context) { // Allow Persistent Secrets //===--------------------------------------------------------------------===// void AllowPersistentSecrets::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.secret_manager->SetEnablePersistentSecrets(input.GetValue()); + auto value = input.DefaultCastAs(LogicalType::BOOLEAN); + config.secret_manager->SetEnablePersistentSecrets(value.GetValue()); } void AllowPersistentSecrets::ResetGlobal(DatabaseInstance *db, DBConfig &config) { @@ -233365,7 +235580,7 @@ void AllowPersistentSecrets::ResetGlobal(DatabaseInstance *db, DBConfig &config) Value AllowPersistentSecrets::GetSetting(ClientContext &context) { auto &config = DBConfig::GetConfig(context); - return config.secret_manager->PersistentSecretsEnabled(); + return Value::BOOLEAN(config.secret_manager->PersistentSecretsEnabled()); } //===--------------------------------------------------------------------===// @@ -233766,6 +235981,29 @@ Value AllowUnsignedExtensionsSetting::GetSetting(ClientContext &context) { return Value::BOOLEAN(config.options.allow_unsigned_extensions); } +//===--------------------------------------------------------------------===// +// Allow Unredacted Secrets +//===--------------------------------------------------------------------===// +void AllowUnredactedSecretsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { + auto new_value = input.GetValue(); + if (db && new_value) { + throw InvalidInputException("Cannot change allow_unredacted_secrets setting while database is running"); + } + config.options.allow_unredacted_secrets = new_value; +} + +void AllowUnredactedSecretsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { + if (db) { + throw InvalidInputException("Cannot change allow_unredacted_secrets setting while database is running"); + } + config.options.allow_unredacted_secrets = DBConfig().options.allow_unredacted_secrets; +} + +Value AllowUnredactedSecretsSetting::GetSetting(ClientContext &context) { + auto &config = DBConfig::GetConfig(context); + return Value::BOOLEAN(config.options.allow_unredacted_secrets); +} + //===--------------------------------------------------------------------===// // Enable Object Cache //===--------------------------------------------------------------------===// @@ -234255,6 +236493,22 @@ Value OldImplicitCasting::GetSetting(ClientContext &context) { return Value::BOOLEAN(config.options.old_implicit_casting); } +//===--------------------------------------------------------------------===// +// Partitioned Write Flush Threshold +//===--------------------------------------------------------------------===// +void PartitionedWriteFlushThreshold::ResetLocal(ClientContext &context) { + ClientConfig::GetConfig(context).partitioned_write_flush_threshold = + ClientConfig().partitioned_write_flush_threshold; +} + +void PartitionedWriteFlushThreshold::SetLocal(ClientContext &context, const Value &input) { + ClientConfig::GetConfig(context).partitioned_write_flush_threshold = input.GetValue(); +} + +Value PartitionedWriteFlushThreshold::GetSetting(ClientContext &context) { + return Value::BIGINT(ClientConfig::GetConfig(context).partitioned_write_flush_threshold); +} + //===--------------------------------------------------------------------===// // Password Setting //===--------------------------------------------------------------------===// @@ -237242,8 +239496,8 @@ void FilterCombiner::GenerateFilters(const std::function= 0 && upper_index >= 0) { + if (lower_index.IsValid() && upper_index.IsValid()) { // found both lower and upper index, create a BETWEEN expression - auto lower_constant = make_uniq(constant_list[lower_index].constant); - auto upper_constant = make_uniq(constant_list[upper_index].constant); + auto lower_constant = + make_uniq(constant_list[lower_index.GetIndex()].constant); + auto upper_constant = + make_uniq(constant_list[upper_index.GetIndex()].constant); auto between = make_uniq(entries[i].get().Copy(), std::move(lower_constant), std::move(upper_constant), lower_inclusive, upper_inclusive); callback(std::move(between)); - } else if (lower_index >= 0) { + } else if (lower_index.IsValid()) { // only lower index found, create simple comparison expression - auto constant = make_uniq(constant_list[lower_index].constant); - auto comparison = make_uniq(constant_list[lower_index].comparison_type, - entries[i].get().Copy(), std::move(constant)); + auto constant = make_uniq(constant_list[lower_index.GetIndex()].constant); + auto comparison = + make_uniq(constant_list[lower_index.GetIndex()].comparison_type, + entries[i].get().Copy(), std::move(constant)); callback(std::move(comparison)); - } else if (upper_index >= 0) { + } else if (upper_index.IsValid()) { // only upper index found, create simple comparison expression - auto constant = make_uniq(constant_list[upper_index].constant); - auto comparison = make_uniq(constant_list[upper_index].comparison_type, - entries[i].get().Copy(), std::move(constant)); + auto constant = make_uniq(constant_list[upper_index.GetIndex()].constant); + auto comparison = + make_uniq(constant_list[upper_index.GetIndex()].comparison_type, + entries[i].get().Copy(), std::move(constant)); callback(std::move(comparison)); } } @@ -237954,7 +240212,9 @@ FilterResult FilterCombiner::AddFilter(Expression &expr) { * It's missing to create another method to add transitive filters from scalar filters, e.g, i > 10 */ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &comparison, bool is_root) { - D_ASSERT(IsGreaterThan(comparison.type) || IsLessThan(comparison.type)); + if (!IsGreaterThan(comparison.type) && !IsLessThan(comparison.type)) { + return FilterResult::UNSUPPORTED; + } // get the LHS and RHS nodes auto &left_node = GetNode(*comparison.left); reference right_node = GetNode(*comparison.right); @@ -238928,7 +241188,11 @@ unique_ptr InClauseRewriter::VisitReplace(BoundOperatorExpression &e chunk.Initialize(context, types); for (idx_t i = 1; i < expr.children.size(); i++) { // resolve this expression to a constant - auto value = ExpressionExecutor::EvaluateScalar(context, *expr.children[i]); + Value value; + if (!ExpressionExecutor::TryEvaluateScalar(context, *expr.children[i], value)) { + // error while evaluating scalar + return nullptr; + } idx_t index = chunk.size(); chunk.SetCardinality(chunk.size() + 1); chunk.SetValue(0, index, value); @@ -241175,15 +243439,16 @@ idx_t RelationManager::NumRelations() { return relations.size(); } -void RelationManager::AddAggregateRelation(LogicalOperator &op, optional_ptr parent, - const RelationStats &stats) { +void RelationManager::AddAggregateOrWindowRelation(LogicalOperator &op, optional_ptr parent, + const RelationStats &stats, LogicalOperatorType op_type) { auto relation = make_uniq(op, parent, stats); auto relation_id = relations.size(); - auto table_indexes = op.GetTableIndex(); - for (auto &index : table_indexes) { - D_ASSERT(relation_mapping.find(index) == relation_mapping.end()); - relation_mapping[index] = relation_id; + auto op_bindings = op.GetColumnBindings(); + for (auto &binding : op_bindings) { + if (relation_mapping.find(binding.table_index) == relation_mapping.end()) { + relation_mapping[binding.table_index] = relation_id; + } } relations.push_back(std::move(relation)); } @@ -241330,7 +243595,7 @@ bool RelationManager::ExtractJoinRelations(LogicalOperator &input_op, if (!datasource_filters.empty()) { operator_stats.cardinality *= RelationStatisticsHelper::DEFAULT_SELECTIVITY; } - AddAggregateRelation(input_op, parent, operator_stats); + AddAggregateOrWindowRelation(input_op, parent, operator_stats, op->type); return true; } case LogicalOperatorType::LOGICAL_WINDOW: { @@ -241340,7 +243605,10 @@ bool RelationManager::ExtractJoinRelations(LogicalOperator &input_op, op->children[0] = optimizer.Optimize(std::move(op->children[0]), &child_stats); auto &window = op->Cast(); auto operator_stats = RelationStatisticsHelper::ExtractWindowStats(window, child_stats); - AddAggregateRelation(input_op, parent, operator_stats); + if (!datasource_filters.empty()) { + operator_stats.cardinality *= RelationStatisticsHelper::DEFAULT_SELECTIVITY; + } + AddAggregateOrWindowRelation(input_op, parent, operator_stats, op->type); return true; } case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: @@ -241422,8 +243690,9 @@ bool RelationManager::ExtractBindings(Expression &expression, unordered_set> RelationManager::ExtractEdges(LogicalOperator &op } join.conditions.clear(); } else { + vector> leftover_expressions; for (auto &expression : f_op.expressions) { if (filter_set.find(*expression) == filter_set.end()) { filter_set.insert(*expression); unordered_set bindings; ExtractBindings(*expression, bindings); + if (bindings.empty()) { + // the filter is on a column that is not in our relational map. (example: limit_rownum) + // in this case we do not create a FilterInfo for it. (duckdb-internal/#1493)s + leftover_expressions.push_back(std::move(expression)); + continue; + } auto &set = set_manager.GetJoinRelation(bindings); auto filter_info = make_uniq(std::move(expression), set, filters_and_bindings.size()); filters_and_bindings.push_back(std::move(filter_info)); } } - f_op.expressions.clear(); + f_op.expressions = std::move(leftover_expressions); } } @@ -242541,30 +244817,6 @@ class RegexOptimizationRule : public Rule { } // namespace duckdb -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp -// -// -//===----------------------------------------------------------------------===// - - - - - - -namespace duckdb { - -class OrderedAggregateOptimizer : public Rule { -public: - explicit OrderedAggregateOptimizer(ExpressionRewriter &rewriter); - - unique_ptr Apply(LogicalOperator &op, vector> &bindings, bool &changes_made, - bool is_root) override; -}; - -} // namespace duckdb @@ -243527,7 +245779,7 @@ namespace duckdb { unique_ptr FilterPushdown::PushdownLimit(unique_ptr op) { auto &limit = op->Cast(); - if (!limit.limit && limit.limit_val == 0) { + if (limit.limit_val.Type() == LimitNodeType::CONSTANT_VALUE && limit.limit_val.GetConstantValue() == 0) { return make_uniq(std::move(op)); } @@ -244193,12 +246445,12 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) { } case LogicalOperatorType::LOGICAL_ANY_JOIN: break; - case LogicalOperatorType::LOGICAL_UNION: - if (!everything_referenced) { - // for UNION we can remove unreferenced columns as long as everything_referenced is false (i.e. we - // encounter a UNION node that is not preceded by a DISTINCT) - // this happens when UNION ALL is used - auto &setop = op.Cast(); + case LogicalOperatorType::LOGICAL_UNION: { + auto &setop = op.Cast(); + if (setop.setop_all && !everything_referenced) { + // for UNION we can remove unreferenced columns if union all is used + // it's possible not all columns are referenced, but unreferenced columns in the union can + // still have an affect on the result of the union vector entries; for (idx_t i = 0; i < setop.column_count; i++) { entries.push_back(i); @@ -244241,6 +246493,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) { remove.VisitOperator(*child); } return; + } case LogicalOperatorType::LOGICAL_EXCEPT: case LogicalOperatorType::LOGICAL_INTERSECT: // for INTERSECT/EXCEPT operations we can't remove anything, just recursively visit the children @@ -245656,9 +247909,8 @@ OrderedAggregateOptimizer::OrderedAggregateOptimizer(ExpressionRewriter &rewrite root->expr_class = ExpressionClass::BOUND_AGGREGATE; } -unique_ptr OrderedAggregateOptimizer::Apply(LogicalOperator &op, vector> &bindings, - bool &changes_made, bool is_root) { - auto &aggr = bindings[0].get().Cast(); +unique_ptr OrderedAggregateOptimizer::Apply(ClientContext &context, BoundAggregateExpression &aggr, + vector> &groups, bool &changes_made) { if (!aggr.order_bys) { // no ORDER BYs defined return nullptr; @@ -245671,7 +247923,7 @@ unique_ptr OrderedAggregateOptimizer::Apply(LogicalOperator &op, vec } // Remove unnecessary ORDER BY clauses and return if nothing remains - if (aggr.order_bys->Simplify(op.Cast().groups)) { + if (aggr.order_bys->Simplify(groups)) { aggr.order_bys.reset(); changes_made = true; return nullptr; @@ -245690,7 +247942,6 @@ unique_ptr OrderedAggregateOptimizer::Apply(LogicalOperator &op, vec return nullptr; } - auto &context = rewriter.context; FunctionBinder binder(context); vector> sort_children; for (auto &order : aggr.order_bys->orders) { @@ -245732,8 +247983,12 @@ unique_ptr OrderedAggregateOptimizer::Apply(LogicalOperator &op, vec auto bound_function = func.functions.GetFunctionByOffset(best_function); return binder.BindAggregateFunction(bound_function, std::move(children), std::move(aggr.filter), aggr.IsDistinct() ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT); +} - return nullptr; +unique_ptr OrderedAggregateOptimizer::Apply(LogicalOperator &op, vector> &bindings, + bool &changes_made, bool is_root) { + auto &aggr = bindings[0].get().Cast(); + return Apply(rewriter.context, aggr, op.Cast().groups, changes_made); } } // namespace duckdb @@ -246660,7 +248915,7 @@ static void AddCharacter(char chr, LikeString &ret, bool contains) { // if we are not converting into a contains, and the string has LIKE special characters // then don't return a possible LIKE match // same if the character is a control character - if (iscntrl(chr) || (!contains && (chr == '%' || chr == '_'))) { + if (iscntrl(static_cast(chr)) || (!contains && (chr == '%' || chr == '_'))) { ret.exists = false; return; } @@ -246979,7 +249234,7 @@ static unique_ptr StatisticsOperationsNumericNumericCast(const B static unique_ptr StatisticsNumericCastSwitch(const BaseStatistics &input, const LogicalType &target) { // Downcasting timestamps to times is not a truncation operation switch (target.id()) { - case LogicalTypeId::TIME: + case LogicalTypeId::TIME: { switch (input.GetType().id()) { case LogicalTypeId::TIMESTAMP: case LogicalTypeId::TIMESTAMP_TZ: @@ -246988,6 +249243,76 @@ static unique_ptr StatisticsNumericCastSwitch(const BaseStatisti break; } break; + } + // FIXME: perform actual stats propagation for these casts + case LogicalTypeId::TIMESTAMP: + case LogicalTypeId::TIMESTAMP_TZ: { + const bool to_timestamp = target.id() == LogicalTypeId::TIMESTAMP; + const bool to_timestamp_tz = target.id() == LogicalTypeId::TIMESTAMP_TZ; + // Casting to timestamp[_tz] (us) from a different unit can not re-use stats + switch (input.GetType().id()) { + case LogicalTypeId::TIMESTAMP_NS: + case LogicalTypeId::TIMESTAMP_MS: + case LogicalTypeId::TIMESTAMP_SEC: + return nullptr; + case LogicalTypeId::TIMESTAMP: { + if (to_timestamp_tz) { + // Both use INT64 physical type, but should not be treated equal + return nullptr; + } + break; + } + case LogicalTypeId::TIMESTAMP_TZ: { + if (to_timestamp) { + // Both use INT64 physical type, but should not be treated equal + return nullptr; + } + break; + } + default: + break; + } + break; + } + case LogicalTypeId::TIMESTAMP_NS: { + // Same as above ^ + switch (input.GetType().id()) { + case LogicalTypeId::TIMESTAMP: + case LogicalTypeId::TIMESTAMP_TZ: + case LogicalTypeId::TIMESTAMP_MS: + case LogicalTypeId::TIMESTAMP_SEC: + return nullptr; + default: + break; + } + break; + } + case LogicalTypeId::TIMESTAMP_MS: { + // Same as above ^ + switch (input.GetType().id()) { + case LogicalTypeId::TIMESTAMP: + case LogicalTypeId::TIMESTAMP_TZ: + case LogicalTypeId::TIMESTAMP_NS: + case LogicalTypeId::TIMESTAMP_SEC: + return nullptr; + default: + break; + } + break; + } + case LogicalTypeId::TIMESTAMP_SEC: { + // Same as above ^ + switch (input.GetType().id()) { + case LogicalTypeId::TIMESTAMP: + case LogicalTypeId::TIMESTAMP_TZ: + case LogicalTypeId::TIMESTAMP_NS: + case LogicalTypeId::TIMESTAMP_MS: + return nullptr; + default: + break; + } + break; + } default: break; } @@ -247893,7 +250218,7 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq // then the whole result should be empty. // TODO: write better CE logic for limits so that we can just look at // join.children[1].estimated_cardinality. - auto limit = make_uniq(1, 0, nullptr, nullptr); + auto limit = make_uniq(BoundLimitNode::ConstantValue(1), BoundLimitNode()); limit->AddChild(std::move(join.children[1])); auto cross_product = LogicalCrossProduct::Create(std::move(join.children[0]), std::move(limit)); *node_ptr = std::move(cross_product); @@ -248163,7 +250488,11 @@ unique_ptr StatisticsPropagator::PropagateStatistics(LogicalLimi // propagate statistics in the child node PropagateStatistics(limit.children[0]); // return the node stats, with as expected cardinality the amount specified in the limit - return make_uniq(limit.limit_val, limit.limit_val); + if (limit.limit_val.Type() == LimitNodeType::CONSTANT_VALUE) { + auto constant_limit = limit.limit_val.GetConstantValue(); + return make_uniq(constant_limit, constant_limit); + } + return nullptr; } } // namespace duckdb @@ -248466,18 +250795,15 @@ bool TopN::CanOptimize(LogicalOperator &op) { op.children[0]->type == LogicalOperatorType::LOGICAL_ORDER_BY) { auto &limit = op.Cast(); - // When there are some expressions in the limit operator, - // we shouldn't use this optimizations. Because of the expressions - // will be lost when it convert to TopN operator. - if (limit.limit || limit.offset) { + if (limit.limit_val.Type() != LimitNodeType::CONSTANT_VALUE) { + // we need LIMIT to be present AND be a constant value for us to be able to use Top-N return false; } - - // This optimization doesn't apply when OFFSET is present without LIMIT - // Or if offset is not constant - if (limit.limit_val != NumericLimits::Maximum() || limit.offset) { - return true; + if (limit.offset_val.Type() == LimitNodeType::EXPRESSION_VALUE) { + // we need offset to be either not set (i.e. limit without offset) OR have offset be + return false; } + return true; } return false; } @@ -248486,8 +250812,12 @@ unique_ptr TopN::Optimize(unique_ptr op) { if (CanOptimize(*op)) { auto &limit = op->Cast(); auto &order_by = (op->children[0])->Cast(); - - auto topn = make_uniq(std::move(order_by.orders), limit.limit_val, limit.offset_val); + auto limit_val = int64_t(limit.limit_val.GetConstantValue()); + int64_t offset_val = 0; + if (limit.offset_val.Type() == LimitNodeType::CONSTANT_VALUE) { + offset_val = limit.offset_val.GetConstantValue(); + } + auto topn = make_uniq(std::move(order_by.orders), limit_val, offset_val); topn->AddChild(std::move(order_by.children[0])); op = std::move(topn); } else { @@ -249213,10 +251543,11 @@ class PipelineInitializeEvent : public BasePipelineEvent { namespace duckdb { -Executor::Executor(ClientContext &context) : context(context) { +Executor::Executor(ClientContext &context) : context(context), executor_tasks(0) { } Executor::~Executor() { + D_ASSERT(executor_tasks == 0); } Executor &Executor::Get(ClientContext &context) { @@ -249583,17 +251914,12 @@ void Executor::InitializeInternal(PhysicalOperator &plan) { void Executor::CancelTasks() { task.reset(); - // we do this by creating weak pointers to all pipelines - // then clearing our references to the pipelines - // and waiting until all pipelines have been destroyed - vector> weak_references; + { lock_guard elock(executor_lock); - weak_references.reserve(pipelines.size()); + // mark the query as cancelled so tasks will early-out cancelled = true; - for (auto &pipeline : pipelines) { - weak_references.push_back(weak_ptr(pipeline)); - } + // destroy all pipelines, events and states for (auto &rec_cte_ref : recursive_ctes) { auto &rec_cte = rec_cte_ref.get().Cast(); rec_cte.recursive_meta_pipeline.reset(); @@ -249604,15 +251930,8 @@ void Executor::CancelTasks() { events.clear(); } // Take all pending tasks and execute them until they cancel - WorkOnTasks(); - // In case there are still tasks being worked, wait for those to properly finish as well - for (auto &weak_ref : weak_references) { - while (true) { - auto weak = weak_ref.lock(); - if (!weak) { - break; - } - } + while (executor_tasks > 0) { + WorkOnTasks(); } } @@ -249842,7 +252161,7 @@ bool Executor::GetPipelinesProgress(double ¤t_progress, uint64_t ¤t_ current_progress = 0; for (size_t i = 0; i < progress.size(); i++) { - D_ASSERT(progress[i] <= 100); + progress[i] = MaxValue(0.0, MinValue(100.0, progress[i])); current_cardinality += double(progress[i]) * double(cardinality[i]) / double(100); current_progress += progress[i] * double(cardinality[i]) / double(total_cardinality); D_ASSERT(current_cardinality <= total_cardinality); @@ -249868,13 +252187,17 @@ unique_ptr Executor::GetResult() { namespace duckdb { -ExecutorTask::ExecutorTask(Executor &executor_p) : executor(executor_p) { +ExecutorTask::ExecutorTask(Executor &executor_p, shared_ptr event_p) + : executor(executor_p), event(std::move(event_p)) { + executor.RegisterTask(); } -ExecutorTask::ExecutorTask(ClientContext &context) : ExecutorTask(Executor::Get(context)) { +ExecutorTask::ExecutorTask(ClientContext &context, shared_ptr event_p) + : ExecutorTask(Executor::Get(context), std::move(event_p)) { } ExecutorTask::~ExecutorTask() { + executor.UnregisterTask(); } void ExecutorTask::Deschedule() { @@ -250159,7 +252482,7 @@ void MetaPipeline::CreateChildPipeline(Pipeline ¤t, PhysicalOperator &op, namespace duckdb { PipelineTask::PipelineTask(Pipeline &pipeline_p, shared_ptr event_p) - : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(std::move(event_p)) { + : ExecutorTask(pipeline_p.executor, std::move(event_p)), pipeline(pipeline_p) { } bool PipelineTask::TaskBlockedOnResult() const { @@ -250254,6 +252577,17 @@ bool Pipeline::ScheduleParallel(shared_ptr &event) { } } idx_t max_threads = source_state->MaxThreads(); + auto &scheduler = TaskScheduler::GetScheduler(executor.context); + idx_t active_threads = scheduler.NumberOfThreads(); + if (max_threads > active_threads) { + max_threads = active_threads; + } + if (sink && sink->sink_state) { + max_threads = sink->sink_state->MaxThreads(max_threads); + } + if (max_threads > active_threads) { + max_threads = active_threads; + } return LaunchScanTasks(event, max_threads); } @@ -250298,11 +252632,6 @@ void Pipeline::Schedule(shared_ptr &event) { bool Pipeline::LaunchScanTasks(shared_ptr &event, idx_t max_threads) { // split the scan up into parts and schedule the parts - auto &scheduler = TaskScheduler::GetScheduler(executor.context); - idx_t active_threads = scheduler.NumberOfThreads(); - if (max_threads > active_threads) { - max_threads = active_threads; - } if (max_threads <= 1) { // too small to parallelize return false; @@ -250932,7 +253261,7 @@ OperatorResultType PipelineExecutor::Execute(DataChunk &input, DataChunk &result in_process_operators.push(current_idx); } else if (result == OperatorResultType::FINISHED) { D_ASSERT(current_chunk.size() == 0); - FinishProcessing(current_idx); + FinishProcessing(NumericCast(current_idx)); return OperatorResultType::FINISHED; } current_chunk.Verify(); @@ -251044,6 +253373,7 @@ void PipelineExecutor::EndOperator(PhysicalOperator &op, optional_ptr + namespace duckdb { //! The PipelineFinishTask calls Finalize on the sink. Note that this is a single-threaded operation, but is executed @@ -251051,11 +253381,10 @@ namespace duckdb { class PipelineFinishTask : public ExecutorTask { public: explicit PipelineFinishTask(Pipeline &pipeline_p, shared_ptr event_p) - : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(std::move(event_p)) { + : ExecutorTask(pipeline_p.executor, std::move(event_p)), pipeline(pipeline_p) { } Pipeline &pipeline; - shared_ptr event; public: TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override { @@ -251123,11 +253452,10 @@ PipelineInitializeEvent::PipelineInitializeEvent(shared_ptr pipeline_p class PipelineInitializeTask : public ExecutorTask { public: explicit PipelineInitializeTask(Pipeline &pipeline_p, shared_ptr event_p) - : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(std::move(event_p)) { + : ExecutorTask(pipeline_p.executor, std::move(event_p)), pipeline(pipeline_p) { } Pipeline &pipeline; - shared_ptr event; public: TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override { @@ -255276,6 +257604,7 @@ class LightweightSemaphore // LICENSE_CHANGE_END + #include #else #include @@ -255288,6 +257617,10 @@ struct SchedulerThread { explicit SchedulerThread(unique_ptr thread_p) : internal_thread(std::move(thread_p)) { } + ~SchedulerThread() { + Allocator::ThreadFlush(0); + } + unique_ptr internal_thread; #endif }; @@ -255364,7 +257697,8 @@ ProducerToken::~ProducerToken() { TaskScheduler::TaskScheduler(DatabaseInstance &db) : db(db), queue(make_uniq()), - allocator_flush_threshold(db.config.options.allocator_flush_threshold), thread_count(0) { + allocator_flush_threshold(db.config.options.allocator_flush_threshold), requested_thread_count(0), + current_thread_count(1) { } TaskScheduler::~TaskScheduler() { @@ -255496,9 +257830,7 @@ static void ThreadExecuteTasks(TaskScheduler *scheduler, atomic *marker) { #endif int32_t TaskScheduler::NumberOfThreads() { - lock_guard t(thread_lock); - auto &config = DBConfig::GetConfig(db); - return threads.size() + config.options.external_threads; + return current_thread_count.load(); } void TaskScheduler::SetThreads(idx_t total_threads, idx_t external_threads) { @@ -255509,13 +257841,13 @@ void TaskScheduler::SetThreads(idx_t total_threads, idx_t external_threads) { if (total_threads < external_threads) { throw SyntaxException("Number of threads can't be smaller than number of external threads!"); } - thread_count = total_threads - external_threads; #else - if (threads.size() != external_threads) { + if (total_threads != external_threads) { throw NotImplementedException( - "DuckDB was compiled without threads! Setting threads != external_threads is not allowed."); + "DuckDB was compiled without threads! Setting total_threads != external_threads is not allowed."); } #endif + requested_thread_count = NumericCast(total_threads - external_threads); } void TaskScheduler::SetAllocatorFlushTreshold(idx_t threshold) { @@ -255535,14 +257867,16 @@ void TaskScheduler::YieldThread() { void TaskScheduler::RelaunchThreads() { lock_guard t(thread_lock); - auto n = thread_count.load(); + auto n = requested_thread_count.load(); RelaunchThreadsInternal(n); } void TaskScheduler::RelaunchThreadsInternal(int32_t n) { #ifndef DUCKDB_NO_THREADS + auto &config = DBConfig::GetConfig(db); idx_t new_thread_count = n; if (threads.size() == new_thread_count) { + current_thread_count = NumericCast(threads.size() + config.options.external_threads); return; } if (threads.size() > new_thread_count) { @@ -255572,6 +257906,7 @@ void TaskScheduler::RelaunchThreadsInternal(int32_t n) { markers.push_back(std::move(marker)); } } + current_thread_count = NumericCast(threads.size() + config.options.external_threads); #endif } @@ -258003,24 +260338,6 @@ unique_ptr ChangeColumnTypeInfo::Copy() const { expression->Copy()); } -//===--------------------------------------------------------------------===// -// SetColumnCommentInfo -//===--------------------------------------------------------------------===// -SetColumnCommentInfo::SetColumnCommentInfo() : AlterTableInfo(AlterTableType::SET_COLUMN_COMMENT) { -} - -SetColumnCommentInfo::SetColumnCommentInfo(AlterEntryData data, string column_name, Value comment_value) - : AlterTableInfo(AlterTableType::SET_COLUMN_COMMENT, std::move(data)), column_name(std::move(column_name)), - comment(std::move(comment_value)) { -} - -SetColumnCommentInfo::~SetColumnCommentInfo() { -} - -unique_ptr SetColumnCommentInfo::Copy() const { - return make_uniq_base(GetAlterEntryData(), column_name, comment); -} - //===--------------------------------------------------------------------===// // SetDefaultInfo //===--------------------------------------------------------------------===// @@ -258140,67 +260457,47 @@ unique_ptr AttachInfo::Copy() const { } } // namespace duckdb -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/parser/parsed_data/comment_on_info.hpp -// -// -//===----------------------------------------------------------------------===// - - - - - namespace duckdb { -struct CommentOnInfo : public ParseInfo { -public: - static constexpr const ParseInfoType TYPE = ParseInfoType::COMMENT_ON_INFO; - -public: - CommentOnInfo(); - - //! Catalog type to comment on - CatalogType type; - - //! The catalog name of the entry to comment on - string catalog; - //! The schema name of the entry to comment on - string schema; - //! The name of the entry to comment on - string name; - - //! The comment, can be NULL or a string - Value comment; - -public: - unique_ptr Copy() const; +SetColumnCommentInfo::SetColumnCommentInfo() + : AlterInfo(AlterType::SET_COLUMN_COMMENT, INVALID_CATALOG, INVALID_SCHEMA, "", OnEntryNotFound::THROW_EXCEPTION), + catalog_entry_type(CatalogType::INVALID), column_name(""), comment_value(Value()) { +} - void Serialize(Serializer &serializer) const override; - static unique_ptr Deserialize(Deserializer &deserializer); -}; +SetColumnCommentInfo::SetColumnCommentInfo(string catalog, string schema, string name, string column_name, + Value comment_value, OnEntryNotFound if_not_found) + : AlterInfo(AlterType::SET_COLUMN_COMMENT, std::move(catalog), std::move(schema), std::move(name), if_not_found), + catalog_entry_type(CatalogType::INVALID), column_name(std::move(column_name)), + comment_value(std::move(comment_value)) { +} -} // namespace duckdb +unique_ptr SetColumnCommentInfo::Copy() const { + auto result = make_uniq(catalog, schema, name, column_name, comment_value, if_not_found); + result->type = type; + return std::move(result); +} +optional_ptr SetColumnCommentInfo::TryResolveCatalogEntry(ClientContext &context) { + auto entry = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, catalog, schema, name, if_not_found); -namespace duckdb { + if (entry) { + catalog_entry_type = entry->type; + return entry; + } -CommentOnInfo::CommentOnInfo() - : ParseInfo(TYPE), catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), name(""), comment(Value()) { + return nullptr; } -unique_ptr CommentOnInfo::Copy() const { - auto result = make_uniq(); - result->type = type; - result->catalog = catalog; - result->schema = schema; - result->name = name; - result->comment = comment; - return result; +// Note: this is a bit of a weird one: the exact type is not yet known: it can be either a view or a column this needs +// to be resolved at bind time. If type is invalid here, the CommentOnColumnInfo was not properly resolved first +CatalogType SetColumnCommentInfo::GetCatalogType() const { + if (catalog_entry_type == CatalogType::INVALID) { + throw InternalException("Attempted to access unresolved "); + } + return catalog_entry_type; } } // namespace duckdb @@ -258630,6 +260927,7 @@ unique_ptr CreateViewInfo::Copy() const { CopyProperties(*result); result->aliases = aliases; result->types = types; + result->column_comments = column_comments; result->query = unique_ptr_cast(query->Copy()); return std::move(result); } @@ -258730,6 +261028,8 @@ ExtraDropSecretInfo::ExtraDropSecretInfo() : ExtraDropInfo(ExtraDropInfoType::SE ExtraDropSecretInfo::ExtraDropSecretInfo(const ExtraDropSecretInfo &info) : ExtraDropInfo(ExtraDropInfoType::SECRET_INFO) { + persist_mode = info.persist_mode; + secret_storage = info.secret_storage; } unique_ptr ExtraDropSecretInfo::Copy() const { @@ -263678,6 +265978,7 @@ typedef struct PGPivotExpr { PGList *groups; /* The set of groups to pivot over (if any) */ PGAlias *alias; /* table alias & optional column aliases */ bool include_nulls; /* Whether or not to include NULL values (UNPIVOT only */ + int location; /* token location, or -1 if unknown */ } PGPivotExpr; typedef struct PGPivotStmt { @@ -263687,6 +265988,7 @@ typedef struct PGPivotStmt { PGList *unpivots; /* The names to unpivot over (UNPIVOT only) */ PGList *columns; /* The set of columns to pivot over */ PGList *groups; /* The set of groups to pivot over (if any) */ + int location; /* token location, or -1 if unknown */ } PGPivotStmt; /* ---------------------- @@ -264839,9 +267141,9 @@ class Transformer { unique_ptr TransformDeallocate(duckdb_libpgquery::PGDeallocateStmt &stmt); unique_ptr TransformPivotStatement(duckdb_libpgquery::PGSelectStmt &select); unique_ptr CreatePivotStatement(unique_ptr statement); - PivotColumn TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot); - vector TransformPivotList(duckdb_libpgquery::PGList &list); - static void TransformPivotInList(unique_ptr &expr, PivotColumnEntry &entry, + PivotColumn TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot, bool is_pivot); + vector TransformPivotList(duckdb_libpgquery::PGList &list, bool is_pivot); + static bool TransformPivotInList(unique_ptr &expr, PivotColumnEntry &entry, bool root_entry = true); //===--------------------------------------------------------------------===// @@ -265294,7 +267596,7 @@ vector SplitQueryStringIntoStatements(const string &query) { // Break sql string down into sql statements using the tokenizer vector query_statements; auto tokens = Parser::Tokenize(query); - auto next_statement_start = 0; + idx_t next_statement_start = 0; for (idx_t i = 1; i < tokens.size(); ++i) { auto &t_prev = tokens[i - 1]; auto &t = tokens[i]; @@ -265629,7 +267931,21 @@ string QueryErrorContext::Format(const string &query, const string &error_messag idx_t start_pos = 0; idx_t line_number = 1; for (idx_t i = 0; i < error_location; i++) { - if (StringUtil::CharacterIsNewline(query[i])) { + bool is_newline = false; + switch (query[i]) { + case '\r': + if (i + 1 >= error_location || query[i + 1] != '\n') { + // not \r\n + is_newline = true; + } + break; + case '\n': + is_newline = true; + break; + default: + break; + } + if (is_newline) { line_number++; start_pos = i + 1; } @@ -266895,7 +269211,8 @@ ExportStatement::ExportStatement(unique_ptr info) : SQLStatement(StatementType::EXPORT_STATEMENT), info(std::move(info)) { } -ExportStatement::ExportStatement(const ExportStatement &other) : SQLStatement(other), info(other.info->Copy()) { +ExportStatement::ExportStatement(const ExportStatement &other) + : SQLStatement(other), info(other.info->Copy()), database(other.database) { } unique_ptr ExportStatement::Copy() const { @@ -267243,8 +269560,8 @@ unique_ptr PrepareStatement::Copy() const { namespace duckdb { -RelationStatement::RelationStatement(shared_ptr relation) - : SQLStatement(StatementType::RELATION_STATEMENT), relation(std::move(relation)) { +RelationStatement::RelationStatement(shared_ptr relation_p) + : SQLStatement(StatementType::RELATION_STATEMENT), relation(std::move(relation_p)) { } unique_ptr RelationStatement::Copy() const { @@ -267796,9 +270113,9 @@ string PivotColumn::ToString() const { if (e > 0) { result += ", "; } - if (entry.star_expr) { + if (entry.expr) { D_ASSERT(entry.values.empty()); - result += entry.star_expr->ToString(); + result += entry.expr->ToString(); } else if (entry.values.size() == 1) { result += entry.values[0].ToSQLString(); } else { @@ -267877,7 +270194,7 @@ PivotColumn PivotColumn::Copy() const { PivotColumnEntry PivotColumnEntry::Copy() const { PivotColumnEntry result; result.values = values; - result.star_expr = star_expr ? star_expr->Copy() : nullptr; + result.expr = expr ? expr->Copy() : nullptr; result.alias = alias; return result; } @@ -268018,7 +270335,9 @@ string ShowRef::ToString() const { result += "DESCRIBE "; } if (query) { + result += "("; result += query->ToString(); + result += ")"; } else if (table_name != "__show_tables_expanded") { result += table_name; } @@ -268487,7 +270806,7 @@ static unique_ptr TransformBooleanTestInternal(unique_ptr TransformBooleanTestIsNull(unique_ptr argument, ExpressionType operator_type, idx_t query_location) { auto result = make_uniq(operator_type, std::move(argument)); - Transformer::SetQueryLocation(*result, query_location); + Transformer::SetQueryLocation(*result, UnsafeNumericCast(query_location)); return std::move(result); } @@ -268559,6 +270878,7 @@ unique_ptr Transformer::TransformCase(duckdb_libpgquery::PGCas + namespace duckdb { unique_ptr Transformer::TransformTypeCast(duckdb_libpgquery::PGTypeCast &root) { @@ -268570,7 +270890,12 @@ unique_ptr Transformer::TransformTypeCast(duckdb_libpgquery::P if (!root.tryCast && target_type == LogicalType::BLOB && root.arg->type == duckdb_libpgquery::T_PGAConst) { auto c = PGPointerCast(root.arg); if (c->val.type == duckdb_libpgquery::T_PGString) { - return make_uniq(Value::BLOB(string(c->val.val.str))); + CastParameters parameters; + if (root.location >= 0) { + parameters.query_location = root.location; + } + auto blob_data = Blob::ToBlob(string(c->val.val.str), parameters); + return make_uniq(Value::BLOB_RAW(blob_data)); } } // transform the expression node @@ -268578,7 +270903,9 @@ unique_ptr Transformer::TransformTypeCast(duckdb_libpgquery::P bool try_cast = root.tryCast; // now create a cast operation - return make_uniq(target_type, std::move(expression), try_cast); + auto result = make_uniq(target_type, std::move(expression), try_cast); + SetQueryLocation(*result, root.location); + return std::move(result); } } // namespace duckdb @@ -268715,9 +271042,9 @@ unique_ptr Transformer::TransformValue(duckdb_libpgquery::PG string_t str_val(val.val.str); bool try_cast_as_integer = true; bool try_cast_as_decimal = true; - int decimal_position = -1; - int num_underscores = 0; - int num_integer_underscores = 0; + optional_idx decimal_position = optional_idx::Invalid(); + idx_t num_underscores = 0; + idx_t num_integer_underscores = 0; for (idx_t i = 0; i < str_val.GetSize(); i++) { if (val.val.str[i] == '.') { // decimal point: cast as either decimal or double @@ -268731,7 +271058,7 @@ unique_ptr Transformer::TransformValue(duckdb_libpgquery::PG } if (val.val.str[i] == '_') { num_underscores++; - if (decimal_position < 0) { + if (!decimal_position.IsValid()) { num_integer_underscores++; } } @@ -268751,11 +271078,11 @@ unique_ptr Transformer::TransformValue(duckdb_libpgquery::PG } } idx_t decimal_offset = val.val.str[0] == '-' ? 3 : 2; - if (try_cast_as_decimal && decimal_position >= 0 && + if (try_cast_as_decimal && decimal_position.IsValid() && str_val.GetSize() - num_underscores < Decimal::MAX_WIDTH_DECIMAL + decimal_offset) { // figure out the width/scale based on the decimal position - auto width = uint8_t(str_val.GetSize() - 1 - num_underscores); - auto scale = uint8_t(width - decimal_position + num_integer_underscores); + auto width = NumericCast(str_val.GetSize() - 1 - num_underscores); + auto scale = NumericCast(width - decimal_position.GetIndex() + num_integer_underscores); if (val.val.str[0] == '-') { width--; } @@ -269354,7 +271681,8 @@ unique_ptr Transformer::TransformInterval(duckdb_libpgquery::P return make_uniq(LogicalType::INTERVAL, std::move(expr)); } - int32_t mask = PGPointerCast(node.typmods->head->data.ptr_value)->val.val.ival; + int32_t mask = NumericCast( + PGPointerCast(node.typmods->head->data.ptr_value)->val.val.ival); // these seemingly random constants are from datetime.hpp // they are copied here to avoid having to include this header // the bitshift is from the function INTERVAL_MASK in the parser @@ -271370,7 +273698,7 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n D_ASSERT(!children.empty()); result_type = LogicalType::UNION(std::move(children)); } else { - int64_t width, scale; + idx_t width, scale; if (base_type == LogicalTypeId::DECIMAL) { // default decimal width/scale width = 18; @@ -271424,7 +273752,7 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n if (scale > width) { throw ParserException("Scale cannot be bigger than width"); } - result_type = LogicalType::DECIMAL(width, scale); + result_type = LogicalType::DECIMAL(NumericCast(width), NumericCast(scale)); break; case LogicalTypeId::INTERVAL: if (modifier_idx > 1) { @@ -271770,6 +274098,7 @@ unique_ptr Transformer::TransformCheckpoint(duckdb_libpgquery::PGC + namespace duckdb { unique_ptr Transformer::TransformCommentOn(duckdb_libpgquery::PGCommentOnStmt &stmt) { @@ -271849,14 +274178,8 @@ unique_ptr Transformer::TransformCommentOn(duckdb_libpgquery::PG info = make_uniq(type, qualified_name.catalog, qualified_name.schema, qualified_name.name, comment_value, OnEntryNotFound::THROW_EXCEPTION); } else if (stmt.object_type == duckdb_libpgquery::PG_OBJECT_COLUMN) { - // Special case: Table Column - AlterEntryData alter_entry_data; - alter_entry_data.catalog = qualified_name.catalog; - alter_entry_data.schema = qualified_name.schema; - alter_entry_data.name = qualified_name.name; - alter_entry_data.if_not_found = OnEntryNotFound::THROW_EXCEPTION; - - info = make_uniq(alter_entry_data, column_name, comment_value); + info = make_uniq(qualified_name.catalog, qualified_name.schema, qualified_name.name, + column_name, comment_value, OnEntryNotFound::THROW_EXCEPTION); } else if (stmt.object_type == duckdb_libpgquery::PG_OBJECT_DATABASE) { throw NotImplementedException("Adding comments to databases is not implemented"); } else if (stmt.object_type == duckdb_libpgquery::PG_OBJECT_SCHEMA) { @@ -273152,7 +275475,8 @@ unique_ptr Transformer::TransformPivotStatement(duckdb_libpgquery::PG } // generate CREATE TYPE statements for each of the columns that do not have an IN list - auto columns = TransformPivotList(*pivot->columns); + bool is_pivot = !pivot->unpivots; + auto columns = TransformPivotList(*pivot->columns, is_pivot); auto pivot_idx = PivotEntryCount(); for (idx_t c = 0; c < columns.size(); c++) { auto &col = columns[c]; @@ -273193,6 +275517,7 @@ unique_ptr Transformer::TransformPivotStatement(duckdb_libpgquery::PG pivot_ref->groups = TransformStringList(pivot->groups); } pivot_ref->pivots = std::move(columns); + SetQueryLocation(*pivot_ref, pivot->location); select_node->from_table = std::move(pivot_ref); // transform order by/limit modifiers TransformModifiers(select, *select_node); @@ -273853,14 +276178,13 @@ namespace duckdb { unique_ptr Transformer::TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) { // we capture the select statement of SHOW - auto select_stmt = PGPointerCast(stmt.stmt); - auto select_node = make_uniq(); select_node->select_list.push_back(make_uniq()); auto show_ref = make_uniq(); show_ref->show_type = stmt.is_summary ? ShowType::SUMMARY : ShowType::DESCRIBE; - show_ref->query = TransformSelectNode(*select_stmt); + auto select = TransformSelect(stmt.stmt); + show_ref->query = std::move(select->node); select_node->from_table = std::move(show_ref); auto result = make_uniq(); @@ -274197,6 +276521,9 @@ unique_ptr Transformer::TransformFrom(optional_ptr Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &root) { @@ -274264,6 +276591,19 @@ unique_ptr Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &r result->ref_type = JoinRefType::CROSS; } result->condition = TransformExpression(root.quals); + if (root.alias) { + // join with an alias - wrap it in a subquery + auto select_node = make_uniq(); + select_node->select_list.push_back(make_uniq()); + select_node->from_table = std::move(result); + auto select = make_uniq(); + select->node = std::move(select_node); + auto subquery = make_uniq(std::move(select)); + SetQueryLocation(*subquery, root.location); + // apply the alias to that subquery + subquery->alias = TransformAlias(root.alias, subquery->column_name_alias); + return std::move(subquery); + } return std::move(result); } @@ -274277,42 +276617,49 @@ unique_ptr Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &r namespace duckdb { -void Transformer::TransformPivotInList(unique_ptr &expr, PivotColumnEntry &entry, bool root_entry) { - if (expr->type == ExpressionType::COLUMN_REF) { +bool Transformer::TransformPivotInList(unique_ptr &expr, PivotColumnEntry &entry, bool root_entry) { + switch (expr->type) { + case ExpressionType::COLUMN_REF: { auto &colref = expr->Cast(); if (colref.IsQualified()) { - throw ParserException("PIVOT IN list cannot contain qualified column references"); + throw ParserException(expr->query_location, "PIVOT IN list cannot contain qualified column references"); } entry.values.emplace_back(colref.GetColumnName()); - } else if (root_entry && expr->type == ExpressionType::FUNCTION) { + return true; + } + case ExpressionType::FUNCTION: { auto &function = expr->Cast(); if (function.function_name != "row") { - throw ParserException("PIVOT IN list must contain columns or lists of columns"); + return false; } for (auto &child : function.children) { - TransformPivotInList(child, entry, false); + if (!TransformPivotInList(child, entry, false)) { + return false; + } } - } else if (root_entry && expr->type == ExpressionType::STAR) { - entry.star_expr = std::move(expr); - } else { + return true; + } + default: { Value val; if (!Transformer::ConstructConstantFromExpression(*expr, val)) { - throw ParserException("PIVOT IN list must contain columns or lists of columns"); + return false; } entry.values.push_back(std::move(val)); + return true; + } } } -PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot) { +PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot, bool is_pivot) { PivotColumn col; if (pivot.pivot_columns) { TransformExpressionList(*pivot.pivot_columns, col.pivot_expressions); for (auto &expr : col.pivot_expressions) { if (expr->IsScalar()) { - throw ParserException("Cannot pivot on constant value \"%s\"", expr->ToString()); + throw ParserException(expr->query_location, "Cannot pivot on constant value \"%s\"", expr->ToString()); } if (expr->HasSubquery()) { - throw ParserException("Cannot pivot on subquery \"%s\"", expr->ToString()); + throw ParserException(expr->query_location, "Cannot pivot on subquery \"%s\"", expr->ToString()); } } } else if (pivot.unpivot_columns) { @@ -274326,7 +276673,18 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot) auto expr = TransformExpression(n); PivotColumnEntry entry; entry.alias = expr->alias; - TransformPivotInList(expr, entry); + auto transformed = TransformPivotInList(expr, entry); + if (!transformed) { + // could not transform into list of constant values + if (is_pivot) { + // for pivot - throw an exception + throw ParserException(expr->query_location, + "PIVOT IN list must contain columns or lists of columns"); + } else { + // for unpivot - we can forward the expression immediately + entry.expr = std::move(expr); + } + } col.entries.push_back(std::move(entry)); } } @@ -274339,11 +276697,11 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot) return col; } -vector Transformer::TransformPivotList(duckdb_libpgquery::PGList &list) { +vector Transformer::TransformPivotList(duckdb_libpgquery::PGList &list, bool is_pivot) { vector result; for (auto node = list.head; node != nullptr; node = node->next) { auto pivot = PGPointerCast(node->data.ptr_value); - result.push_back(TransformPivotColumn(*pivot)); + result.push_back(TransformPivotColumn(*pivot, is_pivot)); } return result; } @@ -274357,41 +276715,40 @@ unique_ptr Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr if (root.unpivots) { result->unpivot_names = TransformStringList(root.unpivots); } - result->pivots = TransformPivotList(*root.pivots); - if (!result->unpivot_names.empty() && result->pivots.size() > 1) { + auto is_pivot = result->unpivot_names.empty(); + result->pivots = TransformPivotList(*root.pivots, is_pivot); + if (!is_pivot && result->pivots.size() > 1) { throw ParserException("UNPIVOT requires a single pivot element"); } if (root.groups) { result->groups = TransformStringList(root.groups); } for (auto &pivot : result->pivots) { - idx_t expected_size; - bool is_pivot = result->unpivot_names.empty(); - if (!result->unpivot_names.empty()) { + if (!is_pivot) { // unpivot if (pivot.unpivot_names.size() != 1) { throw ParserException("UNPIVOT requires a single column name for the PIVOT IN clause"); } D_ASSERT(pivot.pivot_expressions.empty()); - expected_size = pivot.entries[0].values.size(); } else { // pivot - expected_size = pivot.pivot_expressions.size(); + auto expected_size = pivot.pivot_expressions.size(); D_ASSERT(pivot.unpivot_names.empty()); - } - for (auto &entry : pivot.entries) { - if (entry.star_expr && is_pivot) { - throw ParserException("PIVOT IN list must contain columns or lists of columns - star expressions are " - "only supported for UNPIVOT"); - } - if (entry.values.size() != expected_size) { - throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d", - expected_size, entry.values.size()); + for (auto &entry : pivot.entries) { + if (entry.expr) { + throw ParserException("PIVOT IN list must contain columns or lists of columns - expressions are " + "only supported for UNPIVOT"); + } + if (entry.values.size() != expected_size) { + throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d", + expected_size, entry.values.size()); + } } } } result->include_nulls = root.include_nulls; result->alias = TransformAlias(root.alias, result->column_name_alias); + SetQueryLocation(*result, root.location); return std::move(result); } @@ -277172,11 +279529,18 @@ void ExtractParameters(LambdaExpression &expr, vector &column_names, vec BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth, const LogicalType &list_child_type, optional_ptr bind_lambda_function) { - // this is for binding JSON + // This is not a lambda expression, but the JSON arrow operator. if (!bind_lambda_function) { - auto lhs_expr = expr.lhs->Copy(); - OperatorExpression arrow_expr(ExpressionType::ARROW, std::move(lhs_expr), expr.expr->Copy()); - return BindExpression(arrow_expr, depth); + OperatorExpression arrow_expr(ExpressionType::ARROW, std::move(expr.lhs), std::move(expr.expr)); + auto bind_result = BindExpression(arrow_expr, depth); + + // The arrow_expr now contains bound nodes. We move these into the original expression. + if (bind_result.HasError()) { + D_ASSERT(arrow_expr.children.size() == 2); + expr.lhs = std::move(arrow_expr.children[0]); + expr.expr = std::move(arrow_expr.children[1]); + } + return bind_result; } // extract and verify lambda parameters to create dummy columns @@ -277567,7 +279931,9 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth) if (op.type == ExpressionType::GROUPING_FUNCTION) { return BindGroupingFunction(op, depth); } - // bind the children of the operator expression + + // Bind the children of the operator expression. We already create bound expressions. + // Only those children that trigger an error are not yet bound. ErrorData error; for (idx_t i = 0; i < op.children.size(); i++) { BindChild(op.children[i], depth, error); @@ -277575,6 +279941,7 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth) if (error.HasError()) { return BindResult(std::move(error)); } + // all children bound successfully string function_name; switch (op.type) { @@ -277725,6 +280092,8 @@ BindResult ExpressionBinder::BindPositionalReference(unique_ptr &expr, unique_pt D_ASSERT(expr); if (expr->GetExpressionClass() == ExpressionClass::STAR) { D_ASSERT(replacement); + auto alias = expr->alias; expr = replacement->Copy(); + if (!alias.empty()) { + expr->alias = std::move(alias); + } return; } ParsedExpressionIterator::EnumerateChildren( *expr, [&](unique_ptr &child_expr) { ReplaceStarExpression(child_expr, replacement); }); } +static string ReplaceColumnsAlias(const string &alias, const string &column_name, optional_ptr regex) { + string result; + result.reserve(alias.size()); + for (idx_t c = 0; c < alias.size(); c++) { + if (alias[c] == '\\') { + c++; + if (c >= alias.size()) { + throw BinderException("Unterminated backslash in COLUMNS(*) \"%s\" alias. Backslashes must either be " + "escaped or followed by a number", + alias); + } + if (alias[c] == '\\') { + result += "\\"; + continue; + } + if (alias[c] < '0' || alias[c] > '9') { + throw BinderException("Invalid backslash code in COLUMNS(*) \"%s\" alias. Backslashes must either be " + "escaped or followed by a number", + alias); + } + if (alias[c] == '0') { + result += column_name; + } else if (!regex) { + throw BinderException( + "Only the backslash escape code \\0 can be used when no regex is supplied to COLUMNS(*)"); + } else { + string extracted; + RE2::Extract(column_name, *regex, "\\" + alias.substr(c, 1), &extracted); + result += extracted; + } + } else { + result += alias[c]; + } + } + return result; +} + void Binder::ExpandStarExpression(unique_ptr expr, vector> &new_select_list) { StarExpression *star = nullptr; @@ -277849,6 +280259,7 @@ void Binder::ExpandStarExpression(unique_ptr expr, // we have star expressions! expand the list of star expressions bind_context.GenerateAllColumnExpressions(*star, star_list); + unique_ptr regex; if (star->expr) { // COLUMNS with an expression // two options: @@ -277872,15 +280283,15 @@ void Binder::ExpandStarExpression(unique_ptr expr, throw BinderException("COLUMNS does not support NULL as regex argument"); } auto ®ex_str = StringValue::Get(val); - duckdb_re2::RE2 regex(regex_str); - if (!regex.error().empty()) { - auto err = StringUtil::Format("Failed to compile regex \"%s\": %s", regex_str, regex.error()); + regex = make_uniq(regex_str); + if (!regex->error().empty()) { + auto err = StringUtil::Format("Failed to compile regex \"%s\": %s", regex_str, regex->error()); throw BinderException(*star, err); } vector> new_list; for (idx_t i = 0; i < star_list.size(); i++) { auto &colref = star_list[i]->Cast(); - if (!RE2::PartialMatch(colref.GetColumnName(), regex)) { + if (!RE2::PartialMatch(colref.GetColumnName(), *regex)) { continue; } new_list.push_back(std::move(star_list[i])); @@ -277932,6 +280343,28 @@ void Binder::ExpandStarExpression(unique_ptr expr, for (idx_t i = 0; i < star_list.size(); i++) { auto new_expr = expr->Copy(); ReplaceStarExpression(new_expr, star_list[i]); + if (star->columns) { + optional_ptr expr = star_list[i].get(); + while (expr) { + if (expr->type == ExpressionType::COLUMN_REF) { + break; + } + if (expr->type == ExpressionType::OPERATOR_COALESCE) { + expr = expr->Cast().children[0].get(); + } else { + // unknown expression + expr = nullptr; + } + } + if (expr) { + auto &colref = expr->Cast(); + if (new_expr->alias.empty()) { + new_expr->alias = colref.GetColumnName(); + } else { + new_expr->alias = ReplaceColumnsAlias(new_expr->alias, colref.GetColumnName(), regex.get()); + } + } + } new_select_list.push_back(std::move(new_expr)); } } @@ -278408,6 +280841,27 @@ static unique_ptr CastWindowExpression(unique_ptr return std::move(bound); } +static bool IsRangeType(const LogicalType &type) { + switch (type.InternalType()) { + case PhysicalType::INT8: + case PhysicalType::INT16: + case PhysicalType::INT32: + case PhysicalType::INT64: + case PhysicalType::UINT8: + case PhysicalType::UINT16: + case PhysicalType::UINT32: + case PhysicalType::UINT64: + case PhysicalType::INT128: + case PhysicalType::UINT128: + case PhysicalType::FLOAT: + case PhysicalType::DOUBLE: + case PhysicalType::INTERVAL: + return true; + default: + return false; + } +} + static LogicalType BindRangeExpression(ClientContext &context, const string &name, unique_ptr &expr, unique_ptr &order_expr) { @@ -278421,6 +280875,10 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam D_ASSERT(expr.get()); D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION); auto &bound = BoundExpression::GetExpression(*expr); + QueryErrorContext error_context(bound->query_location); + if (bound->return_type == LogicalType::SQLNULL) { + throw BinderException(error_context, "Window RANGE expressions cannot be NULL"); + } children.emplace_back(std::move(bound)); ErrorData error; @@ -278429,6 +280887,11 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam if (!function) { error.Throw(); } + // +/- can be applied to non-scalar types, + // so we can't rely on function binding to catch all problems. + if (!IsRangeType(function->return_type)) { + throw BinderException(error_context, "Invalid type for Window RANGE expression"); + } bound = std::move(function); return bound->return_type; } @@ -278465,7 +280928,7 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) { // If the frame is a RANGE frame and the type is a time, // then we have to convert the time to a timestamp to avoid wrapping. - if (!is_range) { + if (!is_range || error.HasError()) { continue; } auto &order_expr = order.expression; @@ -278491,6 +280954,10 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) { } // Restore any collation expressions + for (auto &part_expr : window.partitions) { + auto &bound_partition = BoundExpression::GetExpression(*part_expr); + ExpressionBinder::PushCollation(context, bound_partition, bound_partition->return_type, true); + } for (auto &order : window.orders) { auto &order_expr = order.expression; auto &bound_order = BoundExpression::GetExpression(*order_expr); @@ -278908,8 +281375,8 @@ class ColumnAliasBinder { public: ColumnAliasBinder(BoundSelectNode &node, const case_insensitive_map_t &alias_map); - bool BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth, bool root_expression, - BindResult &result); + bool BindAlias(ExpressionBinder &enclosing_binder, unique_ptr &expr_ptr, idx_t depth, + bool root_expression, BindResult &result); private: BoundSelectNode &node; @@ -279114,75 +281581,83 @@ unique_ptr Binder::BindOrderExpression(OrderBinder &order_binder, un return bound_expr; } -unique_ptr Binder::BindDelimiter(ClientContext &context, OrderBinder &order_binder, - unique_ptr delimiter, const LogicalType &type, - Value &delimiter_value) { +BoundLimitNode Binder::BindLimitValue(OrderBinder &order_binder, unique_ptr limit_val, + bool is_percentage, bool is_offset) { auto new_binder = Binder::CreateBinder(context, this, true); - if (delimiter->HasSubquery()) { + if (limit_val->HasSubquery()) { if (!order_binder.HasExtraList()) { throw BinderException("Subquery in LIMIT/OFFSET not supported in set operation"); } - return order_binder.CreateExtraReference(std::move(delimiter)); + auto bound_limit = order_binder.CreateExtraReference(std::move(limit_val)); + if (is_percentage) { + return BoundLimitNode::ExpressionPercentage(std::move(bound_limit)); + } else { + return BoundLimitNode::ExpressionValue(std::move(bound_limit)); + } } ExpressionBinder expr_binder(*new_binder, context); - expr_binder.target_type = type; - auto expr = expr_binder.Bind(delimiter); + auto target_type = is_percentage ? LogicalType::DOUBLE : LogicalType::BIGINT; + ; + expr_binder.target_type = target_type; + auto expr = expr_binder.Bind(limit_val); if (expr->IsFoldable()) { //! this is a constant - delimiter_value = ExpressionExecutor::EvaluateScalar(context, *expr).CastAs(context, type); - return nullptr; + auto val = ExpressionExecutor::EvaluateScalar(context, *expr).CastAs(context, target_type); + if (is_percentage) { + D_ASSERT(!is_offset); + double percentage_val; + if (val.IsNull()) { + percentage_val = 100.0; + } else { + percentage_val = val.GetValue(); + } + if (Value::IsNan(percentage_val) || percentage_val < 0 || percentage_val > 100) { + throw OutOfRangeException("Limit percent out of range, should be between 0% and 100%"); + } + return BoundLimitNode::ConstantPercentage(percentage_val); + } else { + int64_t constant_val; + if (val.IsNull()) { + constant_val = is_offset ? 0 : NumericLimits::Maximum(); + } else { + constant_val = val.GetValue(); + } + if (constant_val < 0) { + throw BinderException(expr->query_location, "LIMIT/OFFSET cannot be negative"); + } + return BoundLimitNode::ConstantValue(constant_val); + } } if (!new_binder->correlated_columns.empty()) { throw BinderException("Correlated columns not supported in LIMIT/OFFSET"); } // move any correlated columns to this binder MoveCorrelatedExpressions(*new_binder); - return expr; + if (is_percentage) { + return BoundLimitNode::ExpressionPercentage(std::move(expr)); + } else { + return BoundLimitNode::ExpressionValue(std::move(expr)); + } } duckdb::unique_ptr Binder::BindLimit(OrderBinder &order_binder, LimitModifier &limit_mod) { auto result = make_uniq(); if (limit_mod.limit) { - Value val; - result->limit = BindDelimiter(context, order_binder, std::move(limit_mod.limit), LogicalType::BIGINT, val); - if (!result->limit) { - result->limit_val = val.IsNull() ? NumericLimits::Maximum() : val.GetValue(); - if (result->limit_val < 0) { - throw BinderException("LIMIT cannot be negative"); - } - } + result->limit_val = BindLimitValue(order_binder, std::move(limit_mod.limit), false, false); } if (limit_mod.offset) { - Value val; - result->offset = BindDelimiter(context, order_binder, std::move(limit_mod.offset), LogicalType::BIGINT, val); - if (!result->offset) { - result->offset_val = val.IsNull() ? 0 : val.GetValue(); - if (result->offset_val < 0) { - throw BinderException("OFFSET cannot be negative"); - } - } + result->offset_val = BindLimitValue(order_binder, std::move(limit_mod.offset), false, true); } return std::move(result); } unique_ptr Binder::BindLimitPercent(OrderBinder &order_binder, LimitPercentModifier &limit_mod) { - auto result = make_uniq(); + auto result = make_uniq(); if (limit_mod.limit) { - Value val; - result->limit = BindDelimiter(context, order_binder, std::move(limit_mod.limit), LogicalType::DOUBLE, val); - if (!result->limit) { - result->limit_percent = val.IsNull() ? 100 : val.GetValue(); - if (result->limit_percent < 0.0) { - throw InvalidInputException("Limit percentage can't be negative value"); - } - } + result->limit_val = BindLimitValue(order_binder, std::move(limit_mod.limit), true, false); } if (limit_mod.offset) { - Value val; - result->offset = BindDelimiter(context, order_binder, std::move(limit_mod.offset), LogicalType::BIGINT, val); - if (!result->offset) { - result->offset_val = val.IsNull() ? 0 : val.GetValue(); - } + result->offset_val = BindLimitValue(order_binder, std::move(limit_mod.offset), false, true); } return std::move(result); } @@ -279198,7 +281673,8 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun distinct.distinct_on_targets.empty() ? DistinctType::DISTINCT : DistinctType::DISTINCT_ON; if (distinct.distinct_on_targets.empty()) { for (idx_t i = 0; i < result.names.size(); i++) { - distinct.distinct_on_targets.push_back(make_uniq(Value::INTEGER(1 + i))); + distinct.distinct_on_targets.push_back( + make_uniq(Value::INTEGER(UnsafeNumericCast(1 + i)))); } } for (auto &distinct_on_target : distinct.distinct_on_targets) { @@ -279227,8 +281703,9 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun vector new_orders; for (idx_t i = 0; i < order_binder.MaxCount(); i++) { - new_orders.emplace_back(order_type, null_order, - make_uniq(Value::INTEGER(i + 1))); + new_orders.emplace_back( + order_type, null_order, + make_uniq(Value::INTEGER(UnsafeNumericCast(i + 1)))); } order.orders = std::move(new_orders); } @@ -279340,14 +281817,8 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector } case ResultModifierType::LIMIT_MODIFIER: { auto &limit = bound_mod->Cast(); - AssignReturnType(limit.limit, sql_types); - AssignReturnType(limit.offset, sql_types); - break; - } - case ResultModifierType::LIMIT_PERCENT_MODIFIER: { - auto &limit = bound_mod->Cast(); - AssignReturnType(limit.limit, sql_types); - AssignReturnType(limit.offset, sql_types); + AssignReturnType(limit.limit_val.GetExpression(), sql_types); + AssignReturnType(limit.offset_val.GetExpression(), sql_types); break; } case ResultModifierType::ORDER_MODIFIER: { @@ -280107,7 +282578,6 @@ unique_ptr Binder::CreatePlan(BoundCTENode &node) { - namespace duckdb { unique_ptr Binder::VisitQueryNode(BoundQueryNode &node, unique_ptr root) { @@ -280140,16 +282610,7 @@ unique_ptr Binder::VisitQueryNode(BoundQueryNode &node, unique_ } case ResultModifierType::LIMIT_MODIFIER: { auto &bound = mod->Cast(); - auto limit = make_uniq(bound.limit_val, bound.offset_val, std::move(bound.limit), - std::move(bound.offset)); - limit->AddChild(std::move(root)); - root = std::move(limit); - break; - } - case ResultModifierType::LIMIT_PERCENT_MODIFIER: { - auto &bound = mod->Cast(); - auto limit = make_uniq(bound.limit_percent, bound.offset_val, std::move(bound.limit), - std::move(bound.offset)); + auto limit = make_uniq(std::move(bound.limit_val), std::move(bound.offset_val)); limit->AddChild(std::move(root)); root = std::move(limit); break; @@ -280659,7 +283120,7 @@ static unique_ptr PlanUncorrelatedSubquery(Binder &binder, BoundSubq case SubqueryType::EXISTS: { // uncorrelated EXISTS // we only care about existence, hence we push a LIMIT 1 operator - auto limit = make_uniq(1, 0, nullptr, nullptr); + auto limit = make_uniq(BoundLimitNode::ConstantValue(1), BoundLimitNode()); limit->AddChild(std::move(plan)); plan = std::move(limit); @@ -280709,7 +283170,7 @@ static unique_ptr PlanUncorrelatedSubquery(Binder &binder, BoundSubq // in the uncorrelated case we are only interested in the first result of the query // hence we simply push a LIMIT 1 to get the first row of the subquery - auto limit = make_uniq(1, 0, nullptr, nullptr); + auto limit = make_uniq(BoundLimitNode::ConstantValue(1), BoundLimitNode()); limit->AddChild(std::move(plan)); plan = std::move(limit); @@ -281716,12 +284177,18 @@ void Binder::BindSchemaOrCatalog(ClientContext &context, string &catalog, string if (database) { // we have a database with this name // check if there is a schema - auto schema_obj = Catalog::GetSchema(context, INVALID_CATALOG, schema, OnEntryNotFound::RETURN_NULL); - if (schema_obj) { - auto &attached = schema_obj->catalog.GetAttached(); - throw BinderException( - "Ambiguous reference to catalog or schema \"%s\" - use a fully qualified path like \"%s.%s\"", - schema, attached.GetName(), schema); + auto &search_path = *context.client_data->catalog_search_path; + auto catalog_names = search_path.GetCatalogsForSchema(schema); + if (catalog_names.empty()) { + catalog_names.push_back(DatabaseManager::GetDefaultDatabase(context)); + } + for (auto &catalog_name : catalog_names) { + auto &catalog = Catalog::GetCatalog(context, catalog_name); + if (catalog.CheckAmbiguousCatalogOrSchema(context, schema)) { + throw BinderException( + "Ambiguous reference to catalog or schema \"%s\" - use a fully qualified path like \"%s.%s\"", + schema, catalog_name, schema); + } } catalog = schema; schema = string(); @@ -282851,7 +285318,7 @@ BoundStatement Binder::Bind(DropStatement &stmt) { case CatalogType::TYPE_ENTRY: { BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema); auto entry = Catalog::GetEntry(context, stmt.info->type, stmt.info->catalog, stmt.info->schema, stmt.info->name, - OnEntryNotFound::RETURN_NULL); + stmt.info->if_not_found); if (!entry) { break; } @@ -282999,6 +285466,7 @@ BoundStatement Binder::Bind(ExplainStatement &stmt) { + #include namespace duckdb { @@ -283017,7 +285485,7 @@ string SanitizeExportIdentifier(const string &str) { if (c >= 'A' && c <= 'Z') { // To lowercase - result[i] = tolower(c); + result[i] = NumericCast(tolower(c)); } else { // Substitute to underscore result[i] = '_'; @@ -283111,6 +285579,11 @@ static LogicalType AlterLogicalType(const LogicalType &original, copy_supports_t auto child = AlterLogicalType(ListType::GetChildType(original), type_check); return LogicalType::LIST(child); } + case LogicalTypeId::ARRAY: { + // Attempt to convert the array to a list + auto &child = ArrayType::GetChildType(original); + return AlterLogicalType(LogicalType::LIST(child), type_check); + } case LogicalTypeId::STRUCT: { auto &original_children = StructType::GetChildTypes(original); child_list_t new_children; @@ -283709,18 +286182,21 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl if (!index.is_unique) { continue; } - // does this work with multi-column indexes? auto &indexed_columns = index.column_set; + bool matches = false; for (auto &column : table.GetColumns().Physical()) { if (indexed_columns.count(column.Physical().index)) { - found_matching_indexes++; + matches = true; + break; } } + found_matching_indexes += matches; } + if (!found_matching_indexes) { throw BinderException( "There are no UNIQUE/PRIMARY KEY Indexes that refer to this table, ON CONFLICT is a no-op"); - } else if (storage_info.index_info.size() != 1) { + } else if (found_matching_indexes != 1) { if (insert.action_type != OnConflictAction::NOTHING) { // When no conflict target is provided, and the action type is UPDATE, // we only allow the operation when only a single Index exists @@ -284232,6 +286708,7 @@ BoundStatement Binder::Bind(SetStatement &stmt) { + //! This file contains the binder definitions for statements that do not need to be bound at all and only require a //! straightforward conversion @@ -284243,8 +286720,18 @@ BoundStatement Binder::Bind(AlterStatement &stmt) { result.types = {LogicalType::BOOLEAN}; BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema); - auto entry = Catalog::GetEntry(context, stmt.info->GetCatalogType(), stmt.info->catalog, stmt.info->schema, - stmt.info->name, stmt.info->if_not_found); + optional_ptr entry; + + if (stmt.info->type == AlterType::SET_COLUMN_COMMENT) { + // for column comments we need to an extra step: they can alter a table or a view, we resolve that here. + auto &info = stmt.info->Cast(); + entry = info.TryResolveCatalogEntry(context); + } else { + // All other AlterTypes + entry = Catalog::GetEntry(context, stmt.info->GetCatalogType(), stmt.info->catalog, stmt.info->schema, + stmt.info->name, stmt.info->if_not_found); + } + if (entry) { D_ASSERT(!entry->deleted); auto &catalog = entry->ParentCatalog(); @@ -284975,14 +287462,17 @@ unique_ptr Binder::Bind(BaseTableRef &ref) { } // could not find an alternative: bind again to get the error - table_or_view = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name, - ref.table_name, OnEntryNotFound::THROW_EXCEPTION, error_context); + Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name, ref.table_name, + OnEntryNotFound::THROW_EXCEPTION, error_context); + throw InternalException("Catalog::GetEntry should have thrown an exception above"); } + switch (table_or_view->type) { case CatalogType::TABLE_ENTRY: { // base table: create the BoundBaseTableRef node auto table_index = GenerateTableIndex(); auto &table = table_or_view->Cast(); + properties.read_databases.insert(table.ParentCatalog().GetName()); unique_ptr bind_data; auto scan_function = table.GetScanFunction(context, bind_data); @@ -285038,11 +287528,19 @@ unique_ptr Binder::Bind(BaseTableRef &ref) { auto &bound_subquery = bound_child->Cast(); if (GetBindingMode() != BindingMode::EXTRACT_NAMES) { if (bound_subquery.subquery->types != view_catalog_entry.types) { - throw BinderException("Contents of view were altered: types don't match!"); + auto actual_types = StringUtil::ToString(bound_subquery.subquery->types, ", "); + auto expected_types = StringUtil::ToString(view_catalog_entry.types, ", "); + throw BinderException( + "Contents of view were altered: types don't match! Expected [%s], but found [%s] instead", + expected_types, actual_types); } if (bound_subquery.subquery->names.size() == view_catalog_entry.names.size() && bound_subquery.subquery->names != view_catalog_entry.names) { - throw BinderException("Contents of view were altered: names don't match!"); + auto actual_names = StringUtil::Join(bound_subquery.subquery->names, ", "); + auto expected_names = StringUtil::Join(view_catalog_entry.names, ", "); + throw BinderException( + "Contents of view were altered: names don't match! Expected [%s], but found [%s] instead", + expected_names, actual_names); } } bind_context.AddView(bound_subquery.subquery->GetRootIndex(), subquery.alias, subquery, @@ -285290,6 +287788,13 @@ static vector RemoveDuplicateUsingColumns(const vector &using_co return result; } +unique_ptr Binder::BindJoin(Binder &parent_binder, TableRef &ref) { + unnamed_subquery_index = parent_binder.unnamed_subquery_index; + auto result = Bind(ref); + parent_binder.unnamed_subquery_index = unnamed_subquery_index; + return result; +} + unique_ptr Binder::Bind(JoinRef &ref) { auto result = make_uniq(ref.ref_type); result->left_binder = Binder::CreateBinder(context, this); @@ -285298,10 +287803,10 @@ unique_ptr Binder::Bind(JoinRef &ref) { auto &right_binder = *result->right_binder; result->type = ref.type; - result->left = left_binder.Bind(*ref.left); + result->left = left_binder.BindJoin(*this, *ref.left); { LateralBinder binder(left_binder, context); - result->right = right_binder.Bind(*ref.right); + result->right = right_binder.BindJoin(*this, *ref.right); bool is_lateral = false; // Store the correlated columns in the right binder in bound ref for planning of LATERALs // Ignore the correlated columns in the left binder, flattening handles those correlations @@ -285606,16 +288111,16 @@ static unique_ptr ConstructInitialGrouping(PivotRef &ref, vectorCast(); if (handled_columns.find(columnref.GetColumnName()) == handled_columns.end()) { // not handled - add to grouping set - subquery->groups.group_expressions.push_back( - make_uniq(Value::INTEGER(subquery->select_list.size() + 1))); + subquery->groups.group_expressions.push_back(make_uniq( + Value::INTEGER(UnsafeNumericCast(subquery->select_list.size() + 1)))); subquery->select_list.push_back(make_uniq(columnref.GetColumnName())); } } } else { // if rows are specified only the columns mentioned in rows are added as groups for (auto &row : ref.groups) { - subquery->groups.group_expressions.push_back( - make_uniq(Value::INTEGER(subquery->select_list.size() + 1))); + subquery->groups.group_expressions.push_back(make_uniq( + Value::INTEGER(UnsafeNumericCast(subquery->select_list.size() + 1)))); subquery->select_list.push_back(make_uniq(row)); } } @@ -285691,8 +288196,8 @@ static unique_ptr PivotInitialAggregate(PivotBindState &bind_state, pivot_expr->alias = "__internal_pivot_ref" + std::to_string(++pivot_count); } auto pivot_alias = pivot_expr->alias; - subquery_stage1->groups.group_expressions.push_back( - make_uniq(Value::INTEGER(subquery_stage1->select_list.size() + 1))); + subquery_stage1->groups.group_expressions.push_back(make_uniq( + Value::INTEGER(UnsafeNumericCast(subquery_stage1->select_list.size() + 1)))); subquery_stage1->select_list.push_back(std::move(pivot_expr)); pivot_expr = make_uniq(std::move(pivot_alias)); } @@ -285728,8 +288233,8 @@ static unique_ptr PivotListAggregate(PivotBindState &bind_state, Piv // add all of the groups for (idx_t gr = 0; gr < bind_state.internal_group_names.size(); gr++) { - subquery_stage2->groups.group_expressions.push_back( - make_uniq(Value::INTEGER(subquery_stage2->select_list.size() + 1))); + subquery_stage2->groups.group_expressions.push_back(make_uniq( + Value::INTEGER(UnsafeNumericCast(subquery_stage2->select_list.size() + 1)))); auto group_reference = make_uniq(bind_state.internal_group_names[gr]); group_reference->alias = bind_state.internal_group_names[gr]; subquery_stage2->select_list.push_back(std::move(group_reference)); @@ -285922,7 +288427,7 @@ unique_ptr Binder::BindPivot(PivotRef &ref, vector Binder::BindPivot(PivotRef &ref, vector column_names; + vector> expressions; +}; + +void Binder::ExtractUnpivotEntries(Binder &child_binder, PivotColumnEntry &entry, + vector &unpivot_entries) { + if (!entry.expr) { + // pivot entry without an expression - generate one + UnpivotEntry unpivot_entry; + unpivot_entry.alias = entry.alias; + for (auto &val : entry.values) { + auto column_name = val.ToString(); + if (column_name.empty()) { + throw BinderException("UNPIVOT - empty column name not supported"); + } + unpivot_entry.expressions.push_back(make_uniq(column_name)); + } + unpivot_entries.push_back(std::move(unpivot_entry)); + return; + } + D_ASSERT(entry.values.empty()); + // expand star expressions (if any) + vector> star_columns; + child_binder.ExpandStarExpression(std::move(entry.expr), star_columns); + + for (auto &expr : star_columns) { + // create one pivot entry per result column + UnpivotEntry unpivot_entry; + if (!expr->alias.empty()) { + unpivot_entry.alias = std::move(expr->alias); + } + unpivot_entry.expressions.push_back(std::move(expr)); + unpivot_entries.push_back(std::move(unpivot_entry)); + } +} + +void Binder::ExtractUnpivotColumnName(ParsedExpression &expr, vector &result) { + if (expr.type == ExpressionType::COLUMN_REF) { + auto &colref = expr.Cast(); + result.push_back(colref.GetColumnName()); + return; + } + if (expr.type == ExpressionType::SUBQUERY) { + throw BinderException(expr, "UNPIVOT list cannot contain subqueries"); + } + ParsedExpressionIterator::EnumerateChildren( + expr, [&](ParsedExpression &child) { ExtractUnpivotColumnName(child, result); }); +} + unique_ptr Binder::BindUnpivot(Binder &child_binder, PivotRef &ref, vector> all_columns, unique_ptr &where_clause) { D_ASSERT(ref.groups.empty()); D_ASSERT(ref.pivots.size() == 1); - unique_ptr expr; auto select_node = make_uniq(); select_node->from_table = std::move(ref.source); @@ -286004,34 +288559,32 @@ unique_ptr Binder::BindUnpivot(Binder &child_binder, PivotRef &ref, auto &unpivot = ref.pivots[0]; // handle star expressions in any entries - vector new_entries; + vector unpivot_entries; for (auto &entry : unpivot.entries) { - if (entry.star_expr) { - D_ASSERT(entry.values.empty()); - vector> star_columns; - child_binder.ExpandStarExpression(std::move(entry.star_expr), star_columns); - - for (auto &col : star_columns) { - if (col->type != ExpressionType::COLUMN_REF) { - throw InternalException("Unexpected child of unpivot star - not a ColumnRef"); - } - auto &columnref = col->Cast(); - PivotColumnEntry new_entry; - new_entry.values.emplace_back(columnref.GetColumnName()); - new_entry.alias = columnref.GetColumnName(); - new_entries.push_back(std::move(new_entry)); - } - } else { - new_entries.push_back(std::move(entry)); - } + ExtractUnpivotEntries(child_binder, entry, unpivot_entries); } - unpivot.entries = std::move(new_entries); case_insensitive_set_t handled_columns; case_insensitive_map_t name_map; - for (auto &entry : unpivot.entries) { - for (auto &value : entry.values) { - handled_columns.insert(value.ToString()); + for (auto &entry : unpivot_entries) { + for (auto &unpivot_expr : entry.expressions) { + vector result; + ExtractUnpivotColumnName(*unpivot_expr, result); + if (result.empty()) { + + throw BinderException( + *unpivot_expr, + "UNPIVOT clause must contain exactly one column - expression \"%s\" does not contain any", + unpivot_expr->ToString()); + } + if (result.size() > 1) { + throw BinderException( + *unpivot_expr, + "UNPIVOT clause must contain exactly one column - expression \"%s\" contains multiple (%s)", + unpivot_expr->ToString(), StringUtil::Join(result, ", ")); + } + handled_columns.insert(result[0]); + entry.column_names.push_back(std::move(result[0])); } } @@ -286057,10 +288610,11 @@ unique_ptr Binder::BindUnpivot(Binder &child_binder, PivotRef &ref, } } vector unpivot_names; - for (auto &entry : unpivot.entries) { + for (auto &entry : unpivot_entries) { string generated_name; - for (auto &val : entry.values) { - auto name_entry = name_map.find(val.ToString()); + D_ASSERT(entry.expressions.size() == entry.column_names.size()); + for (idx_t c = 0; c < entry.expressions.size(); c++) { + auto name_entry = name_map.find(entry.column_names[c]); if (name_entry == name_map.end()) { throw InternalException("Unpivot - could not find column name in name map"); } @@ -286072,21 +288626,20 @@ unique_ptr Binder::BindUnpivot(Binder &child_binder, PivotRef &ref, unpivot_names.emplace_back(!entry.alias.empty() ? entry.alias : generated_name); } vector>> unpivot_expressions; - for (idx_t v_idx = 1; v_idx < unpivot.entries.size(); v_idx++) { - if (unpivot.entries[v_idx].values.size() != unpivot.entries[0].values.size()) { + for (idx_t v_idx = 1; v_idx < unpivot_entries.size(); v_idx++) { + if (unpivot_entries[v_idx].expressions.size() != unpivot_entries[0].expressions.size()) { throw BinderException( ref, "UNPIVOT value count mismatch - entry has %llu values, but expected all entries to have %llu values", - unpivot.entries[v_idx].values.size(), unpivot.entries[0].values.size()); + unpivot_entries[v_idx].expressions.size(), unpivot_entries[0].expressions.size()); } } - for (idx_t v_idx = 0; v_idx < unpivot.entries[0].values.size(); v_idx++) { + for (idx_t v_idx = 0; v_idx < unpivot_entries[0].expressions.size(); v_idx++) { vector> expressions; - expressions.reserve(unpivot.entries.size()); - for (auto &entry : unpivot.entries) { - auto colref = make_uniq(entry.values[v_idx].ToString()); - expressions.push_back(std::move(colref)); + expressions.reserve(unpivot_entries.size()); + for (auto &entry : unpivot_entries) { + expressions.push_back(std::move(entry.expressions[v_idx])); } unpivot_expressions.push_back(std::move(expressions)); } @@ -286106,7 +288659,7 @@ unique_ptr Binder::BindUnpivot(Binder &child_binder, PivotRef &ref, ref.unpivot_names.size(), unpivot_expressions.size()); } for (idx_t i = 0; i < unpivot_expressions.size(); i++) { - auto list_expr = make_uniq("list_value", std::move(unpivot_expressions[i])); + auto list_expr = make_uniq("unpivot_list", std::move(unpivot_expressions[i])); vector> unnest_val_children; unnest_val_children.push_back(std::move(list_expr)); auto unnest_val_expr = make_uniq("unnest", std::move(unnest_val_children)); @@ -286289,7 +288842,12 @@ unique_ptr Binder::Bind(SubqueryRef &ref, optional_ptrGetRootIndex(); string subquery_alias; if (ref.alias.empty()) { - subquery_alias = "unnamed_subquery" + to_string(bind_index); + auto index = unnamed_subquery_index++; + subquery_alias = "unnamed_subquery"; + ; + if (index > 1) { + subquery_alias += to_string(index); + } } else { subquery_alias = ref.alias; } @@ -287102,20 +289660,20 @@ unique_ptr Binder::CreatePlan(BoundTableFunction &ref) { namespace duckdb { -Binder *Binder::GetRootBinder() { - Binder *root = this; - while (root->parent) { - root = root->parent.get(); +Binder &Binder::GetRootBinder() { + reference root = *this; + while (root.get().parent) { + root = *root.get().parent; } - return root; + return root.get(); } idx_t Binder::GetBinderDepth() const { - const Binder *root = this; + const_reference root = *this; idx_t depth = 1; - while (root->parent) { + while (root.get().parent) { depth++; - root = root->parent.get(); + root = *root.get().parent; } return depth; } @@ -287380,8 +289938,8 @@ void Binder::AddBoundView(ViewCatalogEntry &view) { } idx_t Binder::GenerateTableIndex() { - auto root_binder = GetRootBinder(); - return root_binder->bound_tables++; + auto &root_binder = GetRootBinder(); + return root_binder.bound_tables++; } void Binder::PushExpressionBinder(ExpressionBinder &binder) { @@ -287407,13 +289965,13 @@ bool Binder::HasActiveBinder() { } vector> &Binder::GetActiveBinders() { - auto root_binder = GetRootBinder(); - return root_binder->active_binders; + auto &root_binder = GetRootBinder(); + return root_binder.active_binders; } void Binder::AddUsingBindingSet(unique_ptr set) { - auto root_binder = GetRootBinder(); - root_binder->bind_context.AddUsingBindingSet(std::move(set)); + auto &root_binder = GetRootBinder(); + root_binder.bind_context.AddUsingBindingSet(std::move(set)); } void Binder::MoveCorrelatedExpressions(Binder &other) { @@ -287482,14 +290040,13 @@ bool Binder::HasMatchingBinding(const string &catalog_name, const string &schema } void Binder::SetBindingMode(BindingMode mode) { - auto root_binder = GetRootBinder(); - // FIXME: this used to also set the 'mode' for the current binder, was that necessary? - root_binder->mode = mode; + auto &root_binder = GetRootBinder(); + root_binder.mode = mode; } BindingMode Binder::GetBindingMode() { - auto root_binder = GetRootBinder(); - return root_binder->mode; + auto &root_binder = GetRootBinder(); + return root_binder.mode; } void Binder::SetCanContainNulls(bool can_contain_nulls_p) { @@ -287509,13 +290066,13 @@ void Binder::SetAlwaysRequireRebind() { } void Binder::AddTableName(string table_name) { - auto root_binder = GetRootBinder(); - root_binder->table_names.insert(std::move(table_name)); + auto &root_binder = GetRootBinder(); + root_binder.table_names.insert(std::move(table_name)); } const unordered_set &Binder::GetTableNames() { - auto root_binder = GetRootBinder(); - return root_binder->table_names; + auto &root_binder = GetRootBinder(); + return root_binder.table_names; } // FIXME: this is extremely naive @@ -287783,6 +290340,73 @@ bool BoundOrderModifier::Simplify(const vector> &groups) return orders.empty(); } +BoundLimitNode::BoundLimitNode(LimitNodeType type, idx_t constant_integer, double constant_percentage, + unique_ptr expression_p) + : type(type), constant_integer(constant_integer), constant_percentage(constant_percentage), + expression(std::move(expression_p)) { +} + +BoundLimitNode::BoundLimitNode() : type(LimitNodeType::UNSET) { +} + +BoundLimitNode::BoundLimitNode(int64_t constant_value) + : type(LimitNodeType::CONSTANT_VALUE), constant_integer(constant_value) { +} + +BoundLimitNode::BoundLimitNode(double percentage_value) + : type(LimitNodeType::CONSTANT_PERCENTAGE), constant_percentage(percentage_value) { +} + +BoundLimitNode::BoundLimitNode(unique_ptr expression_p, bool is_percentage) + : type(is_percentage ? LimitNodeType::EXPRESSION_PERCENTAGE : LimitNodeType::EXPRESSION_VALUE), + expression(std::move(expression_p)) { +} + +BoundLimitNode BoundLimitNode::ConstantValue(int64_t value) { + return BoundLimitNode(value); +} + +BoundLimitNode BoundLimitNode::ConstantPercentage(double percentage) { + return BoundLimitNode(percentage); +} + +BoundLimitNode BoundLimitNode::ExpressionValue(unique_ptr expression) { + return BoundLimitNode(std::move(expression), false); +} + +BoundLimitNode BoundLimitNode::ExpressionPercentage(unique_ptr expression) { + return BoundLimitNode(std::move(expression), true); +} + +idx_t BoundLimitNode::GetConstantValue() const { + if (Type() != LimitNodeType::CONSTANT_VALUE) { + throw InternalException("BoundLimitNode::GetConstantValue called but limit is not a constant value"); + } + return constant_integer; +} + +double BoundLimitNode::GetConstantPercentage() const { + if (Type() != LimitNodeType::CONSTANT_PERCENTAGE) { + throw InternalException("BoundLimitNode::GetConstantPercentage called but limit is not a constant percentage"); + } + return constant_percentage; +} + +const Expression &BoundLimitNode::GetValueExpression() const { + if (Type() != LimitNodeType::EXPRESSION_VALUE) { + throw InternalException("BoundLimitNode::GetValueExpression called but limit is not an expression value"); + } + return *expression; +} + +const Expression &BoundLimitNode::GetPercentageExpression() const { + if (Type() != LimitNodeType::EXPRESSION_PERCENTAGE) { + throw InternalException( + "BoundLimitNode::GetPercentageExpression called but limit is not an expression percentage"); + } + return *expression; +} + BoundLimitModifier::BoundLimitModifier() : BoundResultModifier(ResultModifierType::LIMIT_MODIFIER) { } @@ -287792,10 +290416,6 @@ BoundOrderModifier::BoundOrderModifier() : BoundResultModifier(ResultModifierTyp BoundDistinctModifier::BoundDistinctModifier() : BoundResultModifier(ResultModifierType::DISTINCT_MODIFIER) { } -BoundLimitPercentModifier::BoundLimitPercentModifier() - : BoundResultModifier(ResultModifierType::LIMIT_PERCENT_MODIFIER) { -} - } // namespace duckdb @@ -288150,7 +290770,9 @@ unique_ptr AddCastExpressionInternal(unique_ptr expr, co return expr; } } - return make_uniq(std::move(expr), target_type, std::move(bound_cast), try_cast); + auto result = make_uniq(std::move(expr), target_type, std::move(bound_cast), try_cast); + result->query_location = result->child->query_location; + return std::move(result); } unique_ptr AddCastToTypeInternal(unique_ptr expr, const LogicalType &target_type, @@ -288203,6 +290825,7 @@ unique_ptr BoundCastExpression::AddDefaultCastToType(unique_ptrquery_location; return AddCastToTypeInternal(std::move(expr), target_type, default_set, get_input, try_cast); } @@ -288210,6 +290833,7 @@ unique_ptr BoundCastExpression::AddCastToType(ClientContext &context const LogicalType &target_type, bool try_cast) { auto &cast_functions = DBConfig::GetConfig(context).GetCastFunctions(); GetCastFunctionInput get_input(context); + get_input.query_location = expr->query_location; return AddCastToTypeInternal(std::move(expr), target_type, cast_functions, get_input, try_cast); } @@ -289019,6 +291643,9 @@ bool BoundWindowExpression::Equals(const BaseExpression &other_p) const { if (!Expression::ListEquals(children, other.children)) { return false; } + if (!Expression::ListEquals(partitions, other.partitions)) { + return false; + } // check if the filter expressions are equivalent if (!Expression::Equals(filter_expr, other.filter_expr)) { return false; @@ -289624,16 +292251,20 @@ ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const case_insensiti : node(node), alias_map(alias_map), visited_select_indexes() { } -bool ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth, - bool root_expression, BindResult &result) { +bool ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, unique_ptr &expr_ptr, + idx_t depth, bool root_expression, BindResult &result) { + + D_ASSERT(expr_ptr->GetExpressionClass() == ExpressionClass::COLUMN_REF); + auto &expr = expr_ptr->Cast(); + + // Qualified columns cannot be aliases. if (expr.IsQualified()) { - // qualified columns cannot be aliases return false; } + // We try to find the alias in the alias_map and return false, if no alias exists. auto alias_entry = alias_map.find(expr.column_names[0]); if (alias_entry == alias_map.end()) { - // no alias found return false; } @@ -289642,13 +292273,14 @@ bool ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, ColumnRefE return false; } - // found an alias: bind the alias expression - auto expression = node.original_expressions[alias_entry->second]->Copy(); + // We found an alias, so we copy the alias expression into this expression. + auto original_expr = node.original_expressions[alias_entry->second]->Copy(); + expr_ptr = std::move(original_expr); visited_select_indexes.insert(alias_entry->second); - // since the alias has been found, pass a depth of 0. See Issue 4978 (#16) - // ColumnAliasBinders are only in Having, Qualify and Where Binders - result = enclosing_binder.BindExpression(expression, depth, root_expression); + // Since the alias has been found, we pass a depth of 0. See issue 4978 (#16). + // Only HAVING, QUALIFY, and WHERE binders contain ColumnAliasBinders. + result = enclosing_binder.BindExpression(expr_ptr, depth, root_expression); visited_select_indexes.erase(alias_entry->second); return true; } @@ -289821,13 +292453,17 @@ HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNo } BindResult HavingBinder::BindColumnRef(unique_ptr &expr_ptr, idx_t depth, bool root_expression) { - auto &expr = expr_ptr->Cast(); + + // Keep the original column name to return a meaningful error message. + auto column_name = expr_ptr->Cast().GetColumnName(); + + // Bind the alias. BindResult alias_result; - auto found_alias = column_alias_binder.BindAlias(*this, expr, depth, root_expression, alias_result); + auto found_alias = column_alias_binder.BindAlias(*this, expr_ptr, depth, root_expression, alias_result); + if (found_alias) { if (depth > 0) { - throw BinderException("Having clause cannot reference alias \"%s\" in correlated subquery", - expr.GetColumnName()); + throw BinderException("Having clause cannot reference alias \"%s\" in correlated subquery", column_name); } return alias_result; } @@ -289835,20 +292471,24 @@ BindResult HavingBinder::BindColumnRef(unique_ptr &expr_ptr, i if (aggregate_handling == AggregateHandling::FORCE_AGGREGATES) { if (depth > 0) { throw BinderException( - "Having clause cannot reference column \"%s\" in correlated subquery and group by all", - expr.GetColumnName()); + "Having clause cannot reference column \"%s\" in correlated subquery and group by all", column_name); } + auto expr = duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth); if (expr.HasError()) { return expr; } - auto group_ref = make_uniq( - expr.expression->return_type, ColumnBinding(node.group_index, node.groups.group_expressions.size())); + + // Return a GROUP BY column reference expression. + auto return_type = expr.expression->return_type; + auto column_binding = ColumnBinding(node.group_index, node.groups.group_expressions.size()); + auto group_ref = make_uniq(return_type, column_binding); node.groups.group_expressions.push_back(std::move(expr.expression)); return BindResult(std::move(group_ref)); } + return BindResult(StringUtil::Format( - "column %s must appear in the GROUP BY clause or be used in an aggregate function", expr.ToString())); + "column %s must appear in the GROUP BY clause or be used in an aggregate function", column_name)); } BindResult HavingBinder::BindExpression(unique_ptr &expr_ptr, idx_t depth, bool root_expression) { @@ -289932,6 +292572,7 @@ string InsertBinder::UnsupportedAggregateMessage() { + namespace duckdb { LateralBinder::LateralBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) { @@ -289981,59 +292622,82 @@ string LateralBinder::UnsupportedAggregateMessage() { return "LATERAL join cannot contain aggregates!"; } -class ExpressionDepthReducer : public LogicalOperatorVisitor { -public: - explicit ExpressionDepthReducer(const vector &correlated) : correlated_columns(correlated) { +static void ReduceColumnRefDepth(BoundColumnRefExpression &expr, + const vector &correlated_columns) { + // don't need to reduce this + if (expr.depth == 0) { + return; } - -protected: - void ReduceColumnRefDepth(BoundColumnRefExpression &expr) { - // don't need to reduce this - if (expr.depth == 0) { - return; + for (auto &correlated : correlated_columns) { + if (correlated.binding == expr.binding) { + D_ASSERT(expr.depth > 1); + expr.depth--; + break; } - for (auto &correlated : correlated_columns) { - if (correlated.binding == expr.binding) { - D_ASSERT(expr.depth > 1); - expr.depth--; + } +} + +static void ReduceColumnDepth(vector &columns, + const vector &affected_columns) { + for (auto &s_correlated : columns) { + for (auto &affected : affected_columns) { + if (affected == s_correlated) { + s_correlated.depth--; break; } } } +} - unique_ptr VisitReplace(BoundColumnRefExpression &expr, unique_ptr *expr_ptr) override { - ReduceColumnRefDepth(expr); - return nullptr; +static void ReduceExpressionSubquery(BoundSubqueryExpression &expr, + const vector &correlated_columns) { + ReduceColumnDepth(expr.binder->correlated_columns, correlated_columns); +} + +class ExpressionDepthReducerRecursive : public BoundNodeVisitor { +public: + explicit ExpressionDepthReducerRecursive(const vector &correlated) + : correlated_columns(correlated) { } - void ReduceExpressionSubquery(BoundSubqueryExpression &expr) { - for (auto &s_correlated : expr.binder->correlated_columns) { - for (auto &correlated : correlated_columns) { - if (correlated == s_correlated) { - s_correlated.depth--; - break; - } - } + void VisitExpression(unique_ptr &expression) override { + if (expression->type == ExpressionType::BOUND_COLUMN_REF) { + ReduceColumnRefDepth(expression->Cast(), correlated_columns); + } else if (expression->type == ExpressionType::SUBQUERY) { + ReduceExpressionSubquery(expression->Cast(), correlated_columns); } + BoundNodeVisitor::VisitExpression(expression); } - void ReduceExpressionDepth(Expression &expr) { - if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) { - ReduceColumnRefDepth(expr.Cast()); - } - if (expr.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY) { - auto &subquery_ref = expr.Cast(); - ReduceExpressionSubquery(expr.Cast()); - // Recursively update the depth in the bindings of the children nodes - ExpressionIterator::EnumerateQueryNodeChildren( - *subquery_ref.subquery, [&](Expression &child_expr) { ReduceExpressionDepth(child_expr); }); + void VisitBoundTableRef(BoundTableRef &ref) override { + if (ref.type == TableReferenceType::JOIN) { + // rewrite correlated columns in child joins + auto &bound_join = ref.Cast(); + ReduceColumnDepth(bound_join.correlated_columns, correlated_columns); } + // visit the children of the table ref + BoundNodeVisitor::VisitBoundTableRef(ref); + } + +private: + const vector &correlated_columns; +}; + +class ExpressionDepthReducer : public LogicalOperatorVisitor { +public: + explicit ExpressionDepthReducer(const vector &correlated) : correlated_columns(correlated) { + } + +protected: + unique_ptr VisitReplace(BoundColumnRefExpression &expr, unique_ptr *expr_ptr) override { + ReduceColumnRefDepth(expr, correlated_columns); + return nullptr; } unique_ptr VisitReplace(BoundSubqueryExpression &expr, unique_ptr *expr_ptr) override { - ReduceExpressionSubquery(expr); - ExpressionIterator::EnumerateQueryNodeChildren( - *expr.subquery, [&](Expression &child_expr) { ReduceExpressionDepth(child_expr); }); + ReduceExpressionSubquery(expr, correlated_columns); + ExpressionDepthReducerRecursive recursive(correlated_columns); + recursive.VisitBoundQueryNode(*expr.subquery); return nullptr; } @@ -290195,20 +292859,24 @@ QualifyBinder::QualifyBinder(Binder &binder, ClientContext &context, BoundSelect } BindResult QualifyBinder::BindColumnRef(unique_ptr &expr_ptr, idx_t depth, bool root_expression) { - auto &expr = expr_ptr->Cast(); + auto result = duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth); if (!result.HasError()) { return result; } + // Keep the original column reference's string to return a meaningful error message. + auto expr_string = expr_ptr->Cast().ToString(); + + // Try to bind as an alias. BindResult alias_result; - auto found_alias = column_alias_binder.BindAlias(*this, expr, depth, root_expression, alias_result); + auto found_alias = column_alias_binder.BindAlias(*this, expr_ptr, depth, root_expression, alias_result); if (found_alias) { return alias_result; } - return BindResult(StringUtil::Format("Referenced column %s not found in FROM clause and can't find in alias map.", - expr.ToString())); + return BindResult( + StringUtil::Format("Referenced column %s not found in FROM clause and can't find in alias map.", expr_string)); } BindResult QualifyBinder::BindExpression(unique_ptr &expr_ptr, idx_t depth, bool root_expression) { @@ -290419,17 +293087,18 @@ WhereBinder::WhereBinder(Binder &binder, ClientContext &context, optional_ptr &expr_ptr, idx_t depth, bool root_expression) { - auto &expr = expr_ptr->Cast(); + auto result = ExpressionBinder::BindExpression(expr_ptr, depth); if (!result.HasError() || !column_alias_binder) { return result; } BindResult alias_result; - auto found_alias = column_alias_binder->BindAlias(*this, expr, depth, root_expression, alias_result); + auto found_alias = column_alias_binder->BindAlias(*this, expr_ptr, depth, root_expression, alias_result); if (found_alias) { return alias_result; } + return result; } @@ -290899,86 +293568,61 @@ void ExpressionIterator::EnumerateExpression(unique_ptr &expr, [&](unique_ptr &child) { EnumerateExpression(child, callback); }); } -void ExpressionIterator::EnumerateTableRefChildren(BoundTableRef &ref, - const std::function &callback) { - switch (ref.type) { - case TableReferenceType::EXPRESSION_LIST: { - auto &bound_expr_list = ref.Cast(); - for (auto &expr_list : bound_expr_list.values) { - for (auto &expr : expr_list) { - EnumerateExpression(expr, callback); - } - } - break; - } - case TableReferenceType::JOIN: { - auto &bound_join = ref.Cast(); - if (bound_join.condition) { - EnumerateExpression(bound_join.condition, callback); - } - EnumerateTableRefChildren(*bound_join.left, callback); - EnumerateTableRefChildren(*bound_join.right, callback); - break; - } - case TableReferenceType::SUBQUERY: { - auto &bound_subquery = ref.Cast(); - EnumerateQueryNodeChildren(*bound_subquery.subquery, callback); - break; - } - case TableReferenceType::TABLE_FUNCTION: - case TableReferenceType::EMPTY_FROM: - case TableReferenceType::BASE_TABLE: - case TableReferenceType::CTE: - break; - default: - throw NotImplementedException("Unimplemented table reference type in ExpressionIterator"); - } +void BoundNodeVisitor::VisitExpression(unique_ptr &expression) { + VisitExpressionChildren(*expression); +} + +void BoundNodeVisitor::VisitExpressionChildren(Expression &expr) { + ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr &expr) { VisitExpression(expr); }); } -void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node, - const std::function &callback) { +void BoundNodeVisitor::VisitBoundQueryNode(BoundQueryNode &node) { switch (node.type) { case QueryNodeType::SET_OPERATION_NODE: { auto &bound_setop = node.Cast(); - EnumerateQueryNodeChildren(*bound_setop.left, callback); - EnumerateQueryNodeChildren(*bound_setop.right, callback); + VisitBoundQueryNode(*bound_setop.left); + VisitBoundQueryNode(*bound_setop.right); break; } case QueryNodeType::RECURSIVE_CTE_NODE: { auto &cte_node = node.Cast(); - EnumerateQueryNodeChildren(*cte_node.left, callback); - EnumerateQueryNodeChildren(*cte_node.right, callback); + VisitBoundQueryNode(*cte_node.left); + VisitBoundQueryNode(*cte_node.right); break; } case QueryNodeType::CTE_NODE: { auto &cte_node = node.Cast(); - EnumerateQueryNodeChildren(*cte_node.child, callback); - EnumerateQueryNodeChildren(*cte_node.query, callback); + VisitBoundQueryNode(*cte_node.child); + VisitBoundQueryNode(*cte_node.query); break; } case QueryNodeType::SELECT_NODE: { auto &bound_select = node.Cast(); for (auto &expr : bound_select.select_list) { - EnumerateExpression(expr, callback); + VisitExpression(expr); + } + if (bound_select.where_clause) { + VisitExpression(bound_select.where_clause); } - EnumerateExpression(bound_select.where_clause, callback); for (auto &expr : bound_select.groups.group_expressions) { - EnumerateExpression(expr, callback); + VisitExpression(expr); + } + if (bound_select.having) { + VisitExpression(bound_select.having); } - EnumerateExpression(bound_select.having, callback); for (auto &expr : bound_select.aggregates) { - EnumerateExpression(expr, callback); + VisitExpression(expr); } for (auto &entry : bound_select.unnests) { for (auto &expr : entry.second.expressions) { - EnumerateExpression(expr, callback); + VisitExpression(expr); } } for (auto &expr : bound_select.windows) { - EnumerateExpression(expr, callback); + VisitExpression(expr); } if (bound_select.from_table) { - EnumerateTableRefChildren(*bound_select.from_table, callback); + VisitBoundTableRef(*bound_select.from_table); } break; } @@ -290989,20 +293633,66 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node, switch (node.modifiers[i]->type) { case ResultModifierType::DISTINCT_MODIFIER: for (auto &expr : node.modifiers[i]->Cast().target_distincts) { - EnumerateExpression(expr, callback); + VisitExpression(expr); } break; case ResultModifierType::ORDER_MODIFIER: for (auto &order : node.modifiers[i]->Cast().orders) { - EnumerateExpression(order.expression, callback); + VisitExpression(order.expression); + } + break; + case ResultModifierType::LIMIT_MODIFIER: { + auto &limit_expr = node.modifiers[i]->Cast().limit_val.GetExpression(); + auto &offset_expr = node.modifiers[i]->Cast().offset_val.GetExpression(); + if (limit_expr) { + VisitExpression(limit_expr); + } + if (offset_expr) { + VisitExpression(offset_expr); } break; + } default: break; } } } +void BoundNodeVisitor::VisitBoundTableRef(BoundTableRef &ref) { + switch (ref.type) { + case TableReferenceType::EXPRESSION_LIST: { + auto &bound_expr_list = ref.Cast(); + for (auto &expr_list : bound_expr_list.values) { + for (auto &expr : expr_list) { + VisitExpression(expr); + } + } + break; + } + case TableReferenceType::JOIN: { + auto &bound_join = ref.Cast(); + if (bound_join.condition) { + VisitExpression(bound_join.condition); + } + VisitBoundTableRef(*bound_join.left); + VisitBoundTableRef(*bound_join.right); + break; + } + case TableReferenceType::SUBQUERY: { + auto &bound_subquery = ref.Cast(); + VisitBoundQueryNode(*bound_subquery.subquery); + break; + } + case TableReferenceType::TABLE_FUNCTION: + case TableReferenceType::EMPTY_FROM: + case TableReferenceType::BASE_TABLE: + case TableReferenceType::CTE: + break; + default: + throw NotImplementedException("Unimplemented table reference type in ExpressionIterator"); + } +} + } // namespace duckdb @@ -291613,21 +294303,11 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op, } case LogicalOperatorType::LOGICAL_LIMIT: { auto &limit = op.Cast(); - if (limit.limit) { - callback(&limit.limit); - } - if (limit.offset) { - callback(&limit.offset); - } - break; - } - case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: { - auto &limit = op.Cast(); - if (limit.limit) { - callback(&limit.limit); + if (limit.limit_val.GetExpression()) { + callback(&limit.limit_val.GetExpression()); } - if (limit.offset) { - callback(&limit.offset); + if (limit.offset_val.GetExpression()) { + callback(&limit.offset_val.GetExpression()); } break; } @@ -292825,10 +295505,9 @@ void LogicalJoin::GetExpressionBindings(Expression &expr, unordered_set & namespace duckdb { -LogicalLimit::LogicalLimit(int64_t limit_val, int64_t offset_val, unique_ptr limit, - unique_ptr offset) - : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT), limit_val(limit_val), offset_val(offset_val), - limit(std::move(limit)), offset(std::move(offset)) { +LogicalLimit::LogicalLimit(BoundLimitNode limit_val, BoundLimitNode offset_val) + : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT), limit_val(std::move(limit_val)), + offset_val(std::move(offset_val)) { } vector LogicalLimit::GetColumnBindings() { @@ -292837,8 +295516,17 @@ vector LogicalLimit::GetColumnBindings() { idx_t LogicalLimit::EstimateCardinality(ClientContext &context) { auto child_cardinality = children[0]->EstimateCardinality(context); - if (limit_val >= 0 && idx_t(limit_val) < child_cardinality) { - child_cardinality = limit_val; + switch (limit_val.Type()) { + case LimitNodeType::CONSTANT_VALUE: + if (limit_val.GetConstantValue() < child_cardinality) { + child_cardinality = limit_val.GetConstantValue(); + } + break; + case LimitNodeType::CONSTANT_PERCENTAGE: + child_cardinality = idx_t(double(child_cardinality) * limit_val.GetConstantPercentage()); + break; + default: + break; } return child_cardinality; } @@ -292849,20 +295537,6 @@ void LogicalLimit::ResolveTypes() { } // namespace duckdb -#include - -namespace duckdb { - -idx_t LogicalLimitPercent::EstimateCardinality(ClientContext &context) { - auto child_cardinality = LogicalOperator::EstimateCardinality(context); - if ((limit_percent < 0 || limit_percent > 100) || std::isnan(limit_percent)) { - return child_cardinality; - } - return idx_t(child_cardinality * (limit_percent / 100.0)); -} - -} // namespace duckdb - namespace duckdb { @@ -293311,6 +295985,7 @@ string LogicalWindow::GetName() const { + namespace duckdb { Planner::Planner(ClientContext &context) : binder(Binder::CreateBinder(context)), context(context) { @@ -293464,6 +296139,8 @@ void Planner::VerifyPlan(ClientContext &context, unique_ptr &op if (!OperatorSupportsSerialization(*op)) { return; } + // verify the column bindings of the plan + ColumnBindingResolver::Verify(*op); // format (de)serialization of this operator try { @@ -293644,21 +296321,6 @@ class RewriteCorrelatedExpressions : public LogicalOperatorVisitor { unique_ptr VisitReplace(BoundColumnRefExpression &expr, unique_ptr *expr_ptr) override; unique_ptr VisitReplace(BoundSubqueryExpression &expr, unique_ptr *expr_ptr) override; -private: - //! Helper class used to recursively rewrite correlated expressions within nested subqueries. - class RewriteCorrelatedRecursive { - public: - RewriteCorrelatedRecursive(BoundSubqueryExpression &parent, ColumnBinding base_binding, - column_binding_map_t &correlated_map); - void RewriteJoinRefRecursive(BoundTableRef &ref); - void RewriteCorrelatedSubquery(BoundSubqueryExpression &expr); - void RewriteCorrelatedExpressions(Expression &child); - - BoundSubqueryExpression &parent; - ColumnBinding base_binding; - column_binding_map_t &correlated_map; - }; - private: ColumnBinding base_binding; column_binding_map_t &correlated_map; @@ -293713,6 +296375,7 @@ class RewriteCTEScan : public LogicalOperatorVisitor { + namespace duckdb { FlattenDependentJoins::FlattenDependentJoins(Binder &binder, const vector &correlated, @@ -294147,8 +296810,26 @@ unique_ptr FlattenDependentJoins::PushDownDependentJoinInternal } case LogicalOperatorType::LOGICAL_LIMIT: { auto &limit = plan->Cast(); - if (limit.limit || limit.offset) { - throw ParserException("Non-constant limit or offset not supported in correlated subquery"); + switch (limit.limit_val.Type()) { + case LimitNodeType::CONSTANT_PERCENTAGE: + case LimitNodeType::EXPRESSION_PERCENTAGE: + // NOTE: limit percent could be supported in a manner similar to the LIMIT above + // but instead of filtering by an exact number of rows, the limit should be expressed as + // COUNT computed over the partition multiplied by the percentage + throw ParserException("Limit percent operator not supported in correlated subquery"); + case LimitNodeType::EXPRESSION_VALUE: + throw ParserException("Non-constant limit not supported in correlated subquery"); + default: + break; + } + switch (limit.offset_val.Type()) { + case LimitNodeType::EXPRESSION_VALUE: + throw ParserException("Non-constant offset not supported in correlated subquery"); + case LimitNodeType::CONSTANT_PERCENTAGE: + case LimitNodeType::EXPRESSION_PERCENTAGE: + throw InternalException("Percentage offset in FlattenDependentJoin"); + default: + break; } auto rownum_alias = "limit_rownum"; unique_ptr child; @@ -294195,19 +296876,34 @@ unique_ptr FlattenDependentJoins::PushDownDependentJoinInternal auto row_num_ref = make_uniq(rownum_alias, LogicalType::BIGINT, ColumnBinding(window_index, 0)); - int64_t upper_bound_limit = NumericLimits::Maximum(); - TryAddOperator::Operation(limit.offset_val, limit.limit_val, upper_bound_limit); - auto upper_bound = make_uniq(Value::BIGINT(upper_bound_limit)); - condition = make_uniq(ExpressionType::COMPARE_LESSTHANOREQUALTO, row_num_ref->Copy(), - std::move(upper_bound)); + if (limit.limit_val.Type() == LimitNodeType::CONSTANT_VALUE) { + auto upper_bound_limit = NumericLimits::Maximum(); + auto limit_val = int64_t(limit.limit_val.GetConstantValue()); + if (limit.offset_val.Type() == LimitNodeType::CONSTANT_VALUE) { + // both offset and limit specified - upper bound is offset + limit + auto offset_val = int64_t(limit.offset_val.GetConstantValue()); + TryAddOperator::Operation(limit_val, offset_val, upper_bound_limit); + } else { + // no offset - upper bound is only the limit + upper_bound_limit = limit_val; + } + auto upper_bound = make_uniq(Value::BIGINT(upper_bound_limit)); + condition = make_uniq(ExpressionType::COMPARE_LESSTHANOREQUALTO, + row_num_ref->Copy(), std::move(upper_bound)); + } // we only need to add "row_number >= offset + 1" if offset is bigger than 0 - if (limit.offset_val > 0) { - auto lower_bound = make_uniq(Value::BIGINT(limit.offset_val)); + if (limit.offset_val.Type() == LimitNodeType::CONSTANT_VALUE) { + auto offset_val = int64_t(limit.offset_val.GetConstantValue()); + auto lower_bound = make_uniq(Value::BIGINT(offset_val)); auto lower_comp = make_uniq(ExpressionType::COMPARE_GREATERTHAN, row_num_ref->Copy(), std::move(lower_bound)); - auto conj = make_uniq(ExpressionType::CONJUNCTION_AND, std::move(lower_comp), - std::move(condition)); - condition = std::move(conj); + if (condition) { + auto conj = make_uniq(ExpressionType::CONJUNCTION_AND, + std::move(lower_comp), std::move(condition)); + condition = std::move(conj); + } else { + condition = std::move(lower_comp); + } } filter->expressions.push_back(std::move(condition)); filter->children.push_back(std::move(window)); @@ -294217,12 +296913,6 @@ unique_ptr FlattenDependentJoins::PushDownDependentJoinInternal } return std::move(filter); } - case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: { - // NOTE: limit percent could be supported in a manner similar to the LIMIT above - // but instead of filtering by an exact number of rows, the limit should be expressed as - // COUNT computed over the partition multiplied by the percentage - throw ParserException("Limit percent operator not supported in correlated subquery"); - } case LogicalOperatorType::LOGICAL_WINDOW: { auto &window = plan->Cast(); // push into children @@ -294463,6 +297153,7 @@ unique_ptr HasCorrelatedExpressions::VisitReplace(BoundSubqueryExpre + namespace duckdb { RewriteCorrelatedExpressions::RewriteCorrelatedExpressions(ColumnBinding base_binding, @@ -294522,6 +297213,20 @@ unique_ptr RewriteCorrelatedExpressions::VisitReplace(BoundColumnRef return nullptr; } +//! Helper class used to recursively rewrite correlated expressions within nested subqueries. +class RewriteCorrelatedRecursive : public BoundNodeVisitor { +public: + RewriteCorrelatedRecursive(ColumnBinding base_binding, column_binding_map_t &correlated_map); + + void VisitBoundTableRef(BoundTableRef &ref) override; + void VisitExpression(unique_ptr &expression) override; + + void RewriteCorrelatedSubquery(Binder &binder, BoundQueryNode &subquery); + + ColumnBinding base_binding; + column_binding_map_t &correlated_map; +}; + unique_ptr RewriteCorrelatedExpressions::VisitReplace(BoundSubqueryExpression &expr, unique_ptr *expr_ptr) { if (!expr.IsCorrelated()) { @@ -294529,19 +297234,19 @@ unique_ptr RewriteCorrelatedExpressions::VisitReplace(BoundSubqueryE } // subquery detected within this subquery // recursively rewrite it using the RewriteCorrelatedRecursive class - RewriteCorrelatedRecursive rewrite(expr, base_binding, correlated_map); - rewrite.RewriteCorrelatedSubquery(expr); + RewriteCorrelatedRecursive rewrite(base_binding, correlated_map); + rewrite.RewriteCorrelatedSubquery(*expr.binder, *expr.subquery); return nullptr; } -RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelatedRecursive( - BoundSubqueryExpression &parent, ColumnBinding base_binding, column_binding_map_t &correlated_map) - : parent(parent), base_binding(base_binding), correlated_map(correlated_map) { +RewriteCorrelatedRecursive::RewriteCorrelatedRecursive(ColumnBinding base_binding, + column_binding_map_t &correlated_map) + : base_binding(base_binding), correlated_map(correlated_map) { } -void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteJoinRefRecursive(BoundTableRef &ref) { - // recursively rewrite bindings in the correlated columns for the table ref and all the children +void RewriteCorrelatedRecursive::VisitBoundTableRef(BoundTableRef &ref) { if (ref.type == TableReferenceType::JOIN) { + // rewrite correlated columns in child joins auto &bound_join = ref.Cast(); for (auto &corr : bound_join.correlated_columns) { auto entry = correlated_map.find(corr.binding); @@ -294549,39 +297254,30 @@ void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteJoinRefRec corr.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second); } } - RewriteJoinRefRecursive(*bound_join.left); - RewriteJoinRefRecursive(*bound_join.right); + } else if (ref.type == TableReferenceType::SUBQUERY) { + auto &subquery = ref.Cast(); + RewriteCorrelatedSubquery(*subquery.binder, *subquery.subquery); + return; } + // visit the children of the table ref + BoundNodeVisitor::VisitBoundTableRef(ref); } -void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelatedSubquery( - BoundSubqueryExpression &expr) { +void RewriteCorrelatedRecursive::RewriteCorrelatedSubquery(Binder &binder, BoundQueryNode &subquery) { // rewrite the binding in the correlated list of the subquery) - for (auto &corr : expr.binder->correlated_columns) { + for (auto &corr : binder.correlated_columns) { auto entry = correlated_map.find(corr.binding); if (entry != correlated_map.end()) { corr.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second); } } - // TODO: Cleanup and find a better way to do this - auto &node = *expr.subquery; - if (node.type == QueryNodeType::SELECT_NODE) { - // Found an unplanned select node, need to update column bindings correlated columns in the from tables - auto &bound_select = node.Cast(); - if (bound_select.from_table) { - BoundTableRef &table_ref = *bound_select.from_table; - RewriteJoinRefRecursive(table_ref); - } - } - // now rewrite any correlated BoundColumnRef expressions inside the subquery - ExpressionIterator::EnumerateQueryNodeChildren(*expr.subquery, - [&](Expression &child) { RewriteCorrelatedExpressions(child); }); + VisitBoundQueryNode(subquery); } -void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelatedExpressions(Expression &child) { - if (child.type == ExpressionType::BOUND_COLUMN_REF) { +void RewriteCorrelatedRecursive::VisitExpression(unique_ptr &expression) { + if (expression->type == ExpressionType::BOUND_COLUMN_REF) { // bound column reference - auto &bound_colref = child.Cast(); + auto &bound_colref = expression->Cast(); if (bound_colref.depth == 0) { // not a correlated column, ignore return; @@ -294595,13 +297291,13 @@ void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelated bound_colref.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second); bound_colref.depth--; } - } else if (child.type == ExpressionType::SUBQUERY) { + } else if (expression->type == ExpressionType::SUBQUERY) { // we encountered another subquery: rewrite recursively - D_ASSERT(child.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY); - auto &bound_subquery = child.Cast(); - RewriteCorrelatedRecursive rewrite(bound_subquery, base_binding, correlated_map); - rewrite.RewriteCorrelatedSubquery(bound_subquery); + auto &bound_subquery = expression->Cast(); + RewriteCorrelatedSubquery(*bound_subquery.binder, *bound_subquery.subquery); } + // recurse into the children of this subquery + BoundNodeVisitor::VisitExpression(expression); } RewriteCountAggregates::RewriteCountAggregates(column_binding_map_t &replacement_map) @@ -295026,6 +297722,7 @@ data_ptr_t ArenaAllocator::Allocate(idx_t len) { tail = new_chunk.get(); } head = std::move(new_chunk); + allocated_size += current_capacity; } D_ASSERT(head->current_position + len <= head->maximum_size); auto result = head->data.get() + head->current_position; @@ -295077,12 +297774,14 @@ void ArenaAllocator::Reset() { head->current_position = 0; head->prev = nullptr; } + allocated_size = 0; } void ArenaAllocator::Destroy() { head = nullptr; tail = nullptr; current_capacity = ARENA_ALLOCATOR_INITIAL_CAPACITY; + allocated_size = 0; } void ArenaAllocator::Move(ArenaAllocator &other) { @@ -295090,6 +297789,7 @@ void ArenaAllocator::Move(ArenaAllocator &other) { other.tail = tail; other.head = std::move(head); other.current_capacity = current_capacity; + other.allocated_size = allocated_size; Destroy(); } @@ -295117,6 +297817,11 @@ idx_t ArenaAllocator::SizeInBytes() const { return total_size; } +idx_t ArenaAllocator::AllocationSize() const { + D_ASSERT(head || allocated_size == 0); + return allocated_size; +} + } // namespace duckdb @@ -295170,7 +297875,12 @@ BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p, Mem BlockHandle::~BlockHandle() { // NOLINT: allow internal exceptions // being destroyed, so any unswizzled pointers are just binary junk now. unswizzled = nullptr; - auto &buffer_manager = block_manager.buffer_manager; + if (buffer && buffer->type != FileBufferType::TINY_BUFFER) { + // we kill the latest version in the eviction queue + auto &buffer_manager = block_manager.buffer_manager; + buffer_manager.GetBufferPool().IncrementDeadNodes(); + } + // no references remain to this block: erase if (buffer && state == BlockState::BLOCK_LOADED) { D_ASSERT(memory_charge.size > 0); @@ -295180,7 +297890,7 @@ BlockHandle::~BlockHandle() { // NOLINT: allow internal exceptions } else { D_ASSERT(memory_charge.size == 0); } - buffer_manager.GetBufferPool().PurgeQueue(); + block_manager.UnregisterBlock(block_id, can_destroy); } @@ -295305,8 +298015,8 @@ shared_ptr BlockManager::ConvertToPersistent(block_id_t block_id, s D_ASSERT(old_block->state == BlockState::BLOCK_LOADED); D_ASSERT(old_block->buffer); - // Temp buffers can be larger than the storage block size. But persistent buffers - // cannot. + // Temp buffers can be larger than the storage block size. + // But persistent buffers cannot. D_ASSERT(old_block->buffer->AllocSize() <= Storage::BLOCK_ALLOC_SIZE); // register a block with the new block id @@ -295330,7 +298040,11 @@ shared_ptr BlockManager::ConvertToPersistent(block_id_t block_id, s // persist the new block to disk Write(*new_block->buffer, block_id); - buffer_manager.GetBufferPool().AddToEvictionQueue(new_block); + // potentially purge the queue + auto purge_queue = buffer_manager.GetBufferPool().AddToEvictionQueue(new_block); + if (purge_queue) { + buffer_manager.GetBufferPool().PurgeQueue(); + } return new_block; } @@ -295448,24 +298162,24 @@ struct ProducerToken { template class ConcurrentQueue { private: - //! The queue + //! The standard library queue. std::queue> q; public: - //! Constructor + //! Default constructor. ConcurrentQueue() = default; - //! Constructor + //! Constructor reserving capacity. explicit ConcurrentQueue(size_t capacity) { q.reserve(capacity); } - //! Enqueue item + //! Enqueue an item. template bool enqueue(U &&item) { q.push(std::forward(item)); return true; } - //! Try to dequeue an item + //! Try to dequeue an item. bool try_dequeue(T &item) { if (q.empty()) { return false; @@ -295474,6 +298188,22 @@ class ConcurrentQueue { q.pop(); return true; } + //! Get the size of the queue. + size_t size_approx() const { + return q.size(); + } + //! Dequeues several elements from the queue. + //! Returns the number of elements dequeued. + template + size_t try_dequeue_bulk(It itemFirst, size_t max) { + for (size_t i = 0; i < max; i++) { + if (!try_dequeue(*itemFirst)) { + return i; + } + itemFirst++; + } + return max; + } }; } // namespace duckdb_moodycamel @@ -295513,8 +298243,8 @@ shared_ptr BufferEvictionNode::TryGetBlockHandle() { } BufferPool::BufferPool(idx_t maximum_memory) - : current_memory(0), maximum_memory(maximum_memory), queue(make_uniq()), queue_insertions(0), - temporary_memory_manager(make_uniq()) { + : current_memory(0), maximum_memory(maximum_memory), queue(make_uniq()), + temporary_memory_manager(make_uniq()), evict_queue_insertions(0), total_dead_nodes(0) { for (idx_t i = 0; i < MEMORY_TAG_COUNT; i++) { memory_usage_per_tag[i] = 0; } @@ -295522,16 +298252,26 @@ BufferPool::BufferPool(idx_t maximum_memory) BufferPool::~BufferPool() { } -void BufferPool::AddToEvictionQueue(shared_ptr &handle) { - constexpr int INSERT_INTERVAL = 1024; +bool BufferPool::AddToEvictionQueue(shared_ptr &handle) { + + // The block handle is locked during this operation (Unpin), + // or the block handle is still a local variable (ConvertToPersistent) D_ASSERT(handle->readers == 0); - handle->eviction_timestamp++; - // After each 1024 insertions, run through the queue and purge. - if ((++queue_insertions % INSERT_INTERVAL) == 0) { - PurgeQueue(); + auto ts = ++handle->eviction_timestamp; + + BufferEvictionNode evict_node(weak_ptr(handle), ts); + queue->q.enqueue(evict_node); + + if (ts != 1) { + // we add a newer version, i.e., we kill exactly one previous version + IncrementDeadNodes(); } - queue->q.enqueue(BufferEvictionNode(weak_ptr(handle), handle->eviction_timestamp)); + + if (++evict_queue_insertions % INSERT_INTERVAL == 0) { + return true; + } + return false; } void BufferPool::IncreaseUsedMemory(MemoryTag tag, idx_t size) { @@ -295559,50 +298299,137 @@ BufferPool::EvictionResult BufferPool::EvictBlocks(MemoryTag tag, idx_t extra_me unique_ptr *buffer) { BufferEvictionNode node; TempBufferPoolReservation r(tag, *this, extra_memory); + while (current_memory > memory_limit) { // get a block to unpin from the queue if (!queue->q.try_dequeue(node)) { - // Failed to reserve. Adjust size of temp reservation to 0. - r.Resize(0); - return {false, std::move(r)}; + // we could not dequeue any eviction node, so we try one more time, + // but more aggressively + if (!TryDequeueWithLock(node)) { + // still no success, we return + r.Resize(0); + return {false, std::move(r)}; + } } + // get a reference to the underlying block pointer auto handle = node.TryGetBlockHandle(); if (!handle) { + DecrementDeadNodes(); continue; } + // we might be able to free this block: grab the mutex and check if we can free it lock_guard lock(handle->lock); if (!node.CanUnload(*handle)) { // something changed in the mean-time, bail out + DecrementDeadNodes(); continue; } + // hooray, we can unload the block if (buffer && handle->buffer->AllocSize() == extra_memory) { - // we can actually re-use the memory directly! + // we can re-use the memory directly *buffer = handle->UnloadAndTakeBlock(); return {true, std::move(r)}; - } else { - // release the memory and mark the block as unloaded - handle->Unload(); } + + // release the memory and mark the block as unloaded + handle->Unload(); } return {true, std::move(r)}; } +bool BufferPool::TryDequeueWithLock(BufferEvictionNode &node) { + lock_guard lock(purge_lock); + return queue->q.try_dequeue(node); +} + +void BufferPool::PurgeIteration(const idx_t purge_size) { + // if this purge is significantly smaller or bigger than the previous purge, then + // we need to resize the purge_nodes vector. Note that this barely happens, as we + // purge queue_insertions * PURGE_SIZE_MULTIPLIER nodes + idx_t previous_purge_size = purge_nodes.size(); + if (purge_size < previous_purge_size / 2 || purge_size > previous_purge_size) { + purge_nodes.resize(purge_size); + } + + // bulk purge + idx_t actually_dequeued = queue->q.try_dequeue_bulk(purge_nodes.begin(), purge_size); + + // retrieve all alive nodes that have been wrongly dequeued + idx_t alive_nodes = 0; + for (idx_t i = 0; i < actually_dequeued; i++) { + auto &node = purge_nodes[i]; + auto handle = node.TryGetBlockHandle(); + if (handle) { + queue->q.enqueue(std::move(node)); + alive_nodes++; + } + } + + total_dead_nodes -= actually_dequeued - alive_nodes; +} + void BufferPool::PurgeQueue() { - BufferEvictionNode node; - while (true) { - if (!queue->q.try_dequeue(node)) { + + // only one thread purges the queue, all other threads early-out + if (!purge_lock.try_lock()) { + return; + } + lock_guard lock {purge_lock, std::adopt_lock}; + + // we purge INSERT_INTERVAL * PURGE_SIZE_MULTIPLIER nodes + idx_t purge_size = INSERT_INTERVAL * PURGE_SIZE_MULTIPLIER; + + // get an estimate of the queue size as-of now + idx_t approx_q_size = queue->q.size_approx(); + + // early-out, if the queue is not big enough to justify purging + // - we want to keep the LRU characteristic alive + if (approx_q_size < purge_size * EARLY_OUT_MULTIPLIER) { + return; + } + + // There are two types of situations. + + // For most scenarios, purging INSERT_INTERVAL * PURGE_SIZE_MULTIPLIER nodes is enough. + // Purging more nodes than we insert also counters oscillation for scenarios where most nodes are dead. + // If we always purge slightly more, we trigger a purge less often, as we purge below the trigger. + + // However, if the pressure on the queue becomes too contested, we need to purge more aggressively, + // i.e., we actively seek a specific number of dead nodes to purge. We use the total number of existing dead nodes. + // We detect this situation by observing the queue's ratio between alive vs. dead nodes. If the ratio of alive vs. + // dead nodes grows faster than we can purge, we keep purging until we hit one of the following conditions. + + // 2.1. We're back at an approximate queue size less than purge_size * EARLY_OUT_MULTIPLIER. + // 2.2. We're back at a ratio of 1*alive_node:ALIVE_NODE_MULTIPLIER*dead_nodes. + // 2.3. We've purged the entire queue: max_purges is zero. This is a worst-case scenario, + // guaranteeing that we always exit the loop. + + idx_t max_purges = approx_q_size / purge_size; + while (max_purges != 0) { + + PurgeIteration(purge_size); + + // update relevant sizes and potentially early-out + approx_q_size = queue->q.size_approx(); + + // early-out according to (2.1) + if (approx_q_size < purge_size * EARLY_OUT_MULTIPLIER) { break; } - auto handle = node.TryGetBlockHandle(); - if (!handle) { - continue; - } else { - queue->q.enqueue(std::move(node)); + + idx_t approx_dead_nodes = total_dead_nodes; + approx_dead_nodes = approx_dead_nodes > approx_q_size ? approx_q_size : approx_dead_nodes; + idx_t approx_alive_nodes = approx_q_size - approx_dead_nodes; + + // early-out according to (2.2) + if (approx_alive_nodes * (ALIVE_NODE_MULTIPLIER - 1) > approx_dead_nodes) { break; } + + max_purges--; } } @@ -296107,7 +298934,9 @@ class ColumnData { DataTableInfo &GetTableInfo() const; virtual idx_t GetMaxEntry(); - void IncrementVersion(); + idx_t GetAllocationSize() const { + return allocation_size; + } virtual void SetStart(idx_t new_start); //! The root type of the column @@ -296203,10 +299032,10 @@ class ColumnData { mutex update_lock; //! The updates for this column segment unique_ptr updates; - //! The internal version of the column data - idx_t version; //! The stats of the root segment unique_ptr stats; + //! Total transient allocation size + idx_t allocation_size; }; } // namespace duckdb @@ -296243,7 +299072,7 @@ struct ColumnCheckpointState { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -296540,19 +299369,19 @@ void WriteOverflowStringsToDisk::WriteString(UncompressedStringSegmentState &sta AllocateNewBlock(state, block_manager.GetFreeBlockId()); } result_block = block_id; - result_offset = offset; + result_offset = UnsafeNumericCast(offset); // write the length field auto data_ptr = handle.Ptr(); auto string_length = string.GetSize(); - Store(string_length, data_ptr + offset); + Store(UnsafeNumericCast(string_length), data_ptr + offset); offset += sizeof(uint32_t); // now write the remainder of the string auto strptr = string.GetData(); - uint32_t remaining = string_length; + auto remaining = UnsafeNumericCast(string_length); while (remaining > 0) { - uint32_t to_write = MinValue(remaining, STRING_SPACE - offset); + uint32_t to_write = MinValue(remaining, UnsafeNumericCast(STRING_SPACE - offset)); if (to_write > 0) { memcpy(data_ptr + offset, strptr, to_write); @@ -298987,67 +301816,6 @@ inline void fastpack(const uint64_t *__restrict in, -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/common/numeric_utils.hpp -// -// -//===----------------------------------------------------------------------===// - - - -#include - - -namespace duckdb { - -template -struct MakeSigned { - using type = typename std::make_signed::type; -}; - -template <> -struct MakeSigned { - using type = hugeint_t; -}; - -template <> -struct MakeSigned { - using type = hugeint_t; -}; - -template -struct MakeUnsigned { - using type = typename std::make_unsigned::type; -}; - -template <> -struct MakeUnsigned { - using type = uhugeint_t; -}; - -template <> -struct MakeUnsigned { - using type = uhugeint_t; -}; - -template -struct IsIntegral { - static constexpr bool value = std::is_integral::value; -}; - -template <> -struct IsIntegral { - static constexpr bool value = true; -}; - -template <> -struct IsIntegral { - static constexpr bool value = true; -}; - -} // namespace duckdb namespace duckdb { @@ -299224,10 +301992,10 @@ class BitpackingPrimitives { // Sign bit extension template ::type> static void SignExtend(data_ptr_t dst, bitpacking_width_t width) { - T const mask = T_U(1) << (width - 1); + T const mask = UnsafeNumericCast(T_U(1) << (width - 1)); for (idx_t i = 0; i < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE; ++i) { T value = Load(dst + i * sizeof(T)); - value = value & ((T_U(1) << width) - T_U(1)); + value = UnsafeNumericCast(value & ((T_U(1) << width) - T_U(1))); T result = (value ^ mask) - mask; Store(result, dst + i * sizeof(T)); } @@ -299473,7 +302241,8 @@ class AlpUtils { public: static AlpSamplingParameters GetSamplingParameters(idx_t current_vector_n_values) { - uint32_t n_lookup_values = MinValue(current_vector_n_values, (idx_t)AlpConstants::ALP_VECTOR_SIZE); + auto n_lookup_values = + NumericCast(MinValue(current_vector_n_values, (idx_t)AlpConstants::ALP_VECTOR_SIZE)); //! We sample equidistant values within a vector; to do this we jump a fixed number of values uint32_t n_sampled_increments = MaxValue(1, (int32_t)std::ceil((double)n_lookup_values / AlpConstants::SAMPLES_PER_VECTOR)); @@ -299828,7 +302597,7 @@ struct AlpCompression { state.encoded_integers[i] = encoded_value; //! We detect exceptions using a predicated comparison auto is_exception = (decoded_value != actual_value); - state.exceptions_positions[exceptions_idx] = i; + state.exceptions_positions[exceptions_idx] = UnsafeNumericCast(i); exceptions_idx += is_exception; } @@ -300046,7 +302815,7 @@ bool AlpAnalyze(AnalyzeState &state, Vector &input, idx_t count) { T value = data[idx]; //! We resolve null values with a predicated comparison bool is_null = !vdata.validity.RowIsValid(idx); - current_vector_null_positions[nulls_idx] = i; + current_vector_null_positions[nulls_idx] = UnsafeNumericCast(i); nulls_idx += is_null; current_vector_values[i] = value; } @@ -300095,6 +302864,10 @@ idx_t AlpFinalAnalyze(AnalyzeState &state) { // Flush last unfinished segment analyze_state.FlushSegment(); + if (compressed_values == 0) { + return DConstants::INVALID_INDEX; + } + // We estimate the size by taking into account the portion of the values we took const auto factor_of_sampling = analyze_state.total_values_count / compressed_values; const auto final_analyze_size = analyze_state.TotalUsedBytes() * factor_of_sampling; @@ -300283,7 +303056,7 @@ struct AlpCompressionState : public CompressionState { Store(state.frame_of_reference, data_ptr); data_ptr += AlpConstants::FOR_SIZE; - Store(state.bit_width, data_ptr); + Store(UnsafeNumericCast(state.bit_width), data_ptr); data_ptr += AlpConstants::BIT_WIDTH_SIZE; memcpy((void *)data_ptr, (void *)state.values_encoded, state.bp_size); @@ -300308,7 +303081,7 @@ struct AlpCompressionState : public CompressionState { // Write pointer to the vector data (metadata) metadata_ptr -= sizeof(uint32_t); Store(next_vector_byte_index_start, metadata_ptr); - next_vector_byte_index_start = UsedSpace(); + next_vector_byte_index_start = NumericCast(UsedSpace()); vectors_flushed++; vector_idx = 0; @@ -300348,7 +303121,7 @@ struct AlpCompressionState : public CompressionState { } // Store the offset to the end of metadata (to be used as a backwards pointer in decoding) - Store(total_segment_size, dataptr); + Store(NumericCast(total_segment_size), dataptr); handle.Destroy(); checkpoint_state.FlushSegment(std::move(current_segment), total_segment_size); @@ -300386,7 +303159,7 @@ struct AlpCompressionState : public CompressionState { T value = data[idx]; bool is_null = !vdata.validity.RowIsValid(idx); //! We resolve null values with a predicated comparison - vector_null_positions[nulls_idx] = vector_idx + i; + vector_null_positions[nulls_idx] = UnsafeNumericCast(vector_idx + i); nulls_idx += is_null; input_vector[vector_idx + i] = value; } @@ -300845,6 +303618,7 @@ class AlpRDConstants { + #include namespace duckdb { @@ -300937,7 +303711,8 @@ struct AlpRDCompression { if (PERSIST_DICT) { for (idx_t dict_idx = 0; dict_idx < actual_dictionary_size; dict_idx++) { //! The dict keys are mapped to the left part themselves - state.left_parts_dict[dict_idx] = left_parts_sorted_repetitions[dict_idx].hash; + state.left_parts_dict[dict_idx] = + UnsafeNumericCast(left_parts_sorted_repetitions[dict_idx].hash); state.left_parts_dict_map.insert({state.left_parts_dict[dict_idx], dict_idx}); } //! Pararelly we store a map of the dictionary to quickly resolve exceptions during encoding @@ -300946,24 +303721,24 @@ struct AlpRDCompression { } state.left_bit_width = left_bit_width; state.right_bit_width = right_bit_width; - state.actual_dictionary_size = actual_dictionary_size; + state.actual_dictionary_size = UnsafeNumericCast(actual_dictionary_size); D_ASSERT(state.left_bit_width > 0 && state.right_bit_width > 0 && state.left_bit_width <= AlpRDConstants::MAX_DICTIONARY_BIT_WIDTH && state.actual_dictionary_size <= AlpRDConstants::MAX_DICTIONARY_SIZE); } - double estimated_size = - EstimateCompressionSize(right_bit_width, left_bit_width, exceptions_count, values.size()); + double estimated_size = EstimateCompressionSize(right_bit_width, left_bit_width, + UnsafeNumericCast(exceptions_count), values.size()); return estimated_size; } static double FindBestDictionary(const vector &values, State &state) { - uint8_t right_bit_width; + uint8_t right_bit_width = 0; double best_dict_size = NumericLimits::Maximum(); //! Finding the best position to CUT the values for (idx_t i = 1; i <= AlpRDConstants::CUTTING_LIMIT; i++) { - uint8_t candidate_right_bit_width = EXACT_TYPE_BITSIZE - i; + uint8_t candidate_right_bit_width = UnsafeNumericCast(EXACT_TYPE_BITSIZE - i); double estimated_size = BuildLeftPartsDictionary(values, candidate_right_bit_width, state); if (estimated_size <= best_dict_size) { right_bit_width = candidate_right_bit_width; @@ -300984,7 +303759,7 @@ struct AlpRDCompression { for (idx_t i = 0; i < n_values; i++) { EXACT_TYPE tmp = input_vector[i]; right_parts[i] = tmp & ((1ULL << state.right_bit_width) - 1); - left_parts[i] = (tmp >> state.right_bit_width); + left_parts[i] = UnsafeNumericCast(tmp >> state.right_bit_width); } // Dictionary encoding for left parts @@ -301002,7 +303777,7 @@ struct AlpRDCompression { //! Left parts not found in the dictionary are stored as exceptions if (dictionary_index >= state.actual_dictionary_size) { state.exceptions[state.exceptions_count] = dictionary_key; - state.exceptions_positions[state.exceptions_count] = i; + state.exceptions_positions[state.exceptions_count] = UnsafeNumericCast(i); state.exceptions_count++; } } @@ -301066,6 +303841,7 @@ struct AlpRDDecompression { + #include namespace duckdb { @@ -301133,7 +303909,7 @@ bool AlpRDAnalyze(AnalyzeState &state, Vector &input, idx_t count) { current_vector_sample[sample_idx] = value; //! We resolve null values with a predicated comparison bool is_null = !vdata.validity.RowIsValid(idx); - current_vector_null_positions[nulls_idx] = sample_idx; + current_vector_null_positions[nulls_idx] = UnsafeNumericCast(sample_idx); nulls_idx += is_null; sample_idx++; } @@ -301159,6 +303935,9 @@ bool AlpRDAnalyze(AnalyzeState &state, Vector &input, idx_t count) { template idx_t AlpRDFinalAnalyze(AnalyzeState &state) { auto &analyze_state = (AlpRDAnalyzeState &)state; + if (analyze_state.total_values_count == 0) { + return DConstants::INVALID_INDEX; + } double factor_of_sampling = 1 / ((double)analyze_state.rowgroup_sample.size() / analyze_state.total_values_count); // Finding which is the best dictionary for the sample @@ -301354,7 +304133,7 @@ struct AlpRDCompressionState : public CompressionState { // Write pointer to the vector data (metadata) metadata_ptr -= AlpRDConstants::METADATA_POINTER_SIZE; Store(next_vector_byte_index_start, metadata_ptr); - next_vector_byte_index_start = UsedSpace(); + next_vector_byte_index_start = NumericCast(UsedSpace()); vectors_flushed++; vector_idx = 0; @@ -301394,7 +304173,7 @@ struct AlpRDCompressionState : public CompressionState { } // Store the offset to the end of metadata (to be used as a backwards pointer in decoding) - Store(total_segment_size, dataptr); + Store(NumericCast(total_segment_size), dataptr); dataptr += AlpRDConstants::METADATA_POINTER_SIZE; // Store the right bw for the segment @@ -301447,7 +304226,7 @@ struct AlpRDCompressionState : public CompressionState { EXACT_TYPE value = Load(const_data_ptr_cast(&data[idx])); bool is_null = !vdata.validity.RowIsValid(idx); //! We resolve null values with a predicated comparison - vector_null_positions[nulls_idx] = vector_idx + i; + vector_null_positions[nulls_idx] = UnsafeNumericCast(vector_idx + i); nulls_idx += is_null; input_vector[vector_idx + i] = value; } @@ -303138,6 +305917,7 @@ void HugeIntPacker::Unpack(const uint32_t *__restrict in, uhugeint_t *__restrict + namespace duckdb { //! Every byte read touches at most 2 bytes (1 if it's perfectly aligned) @@ -303199,7 +305979,7 @@ struct BitReader { } inline uint8_t InnerReadByte(const uint8_t &offset) { - uint8_t result = input[ByteIndex() + offset] << BitIndex() | + uint8_t result = static_cast(input[ByteIndex() + offset] << BitIndex()) | ((input[ByteIndex() + offset + 1] & REMAINDER_MASKS[8 + BitIndex()]) >> (8 - BitIndex())); return result; } @@ -303242,30 +306022,30 @@ struct BitReader { inline T ReadBytes(const uint8_t &remainder) { T result = 0; if (BYTES > 0) { - result = result << 8 | InnerReadByte(0); + result = UnsafeNumericCast(result << 8 | InnerReadByte(0)); } if (BYTES > 1) { - result = result << 8 | InnerReadByte(1); + result = UnsafeNumericCast(result << 8 | InnerReadByte(1)); } if (BYTES > 2) { - result = result << 8 | InnerReadByte(2); + result = UnsafeNumericCast(result << 8 | InnerReadByte(2)); } if (BYTES > 3) { - result = result << 8 | InnerReadByte(3); + result = UnsafeNumericCast(result << 8 | InnerReadByte(3)); } if (BYTES > 4) { - result = result << 8 | InnerReadByte(4); + result = UnsafeNumericCast(result << 8 | InnerReadByte(4)); } if (BYTES > 5) { - result = result << 8 | InnerReadByte(5); + result = UnsafeNumericCast(result << 8 | InnerReadByte(5)); } if (BYTES > 6) { - result = result << 8 | InnerReadByte(6); + result = UnsafeNumericCast(result << 8 | InnerReadByte(6)); } if (BYTES > 7) { - result = result << 8 | InnerReadByte(7); + result = UnsafeNumericCast(result << 8 | InnerReadByte(7)); } - result = result << remainder | InnerRead(remainder, BYTES); + result = UnsafeNumericCast(result << remainder | InnerRead(remainder, BYTES)); index += (BYTES << 3) + remainder; return result; } @@ -303339,6 +306119,7 @@ constexpr uint8_t BitReader::MASKS[]; + #ifdef DEBUG @@ -303420,7 +306201,8 @@ class LeadingZeroBuffer { public: #ifdef DEBUG uint8_t ExtractValue(uint32_t value, uint8_t index) { - return (value & LeadingZeroBufferConstants::MASKS[index]) >> LeadingZeroBufferConstants::SHIFTS[index]; + return NumericCast((value & LeadingZeroBufferConstants::MASKS[index]) >> + LeadingZeroBufferConstants::SHIFTS[index]); } #endif @@ -303469,8 +306251,8 @@ class LeadingZeroBuffer { const auto buffer_idx = BlockIndex(); auto const temp = Load(buffer + buffer_idx); - const uint8_t result = - (temp & LeadingZeroBufferConstants::MASKS[counter & 7]) >> LeadingZeroBufferConstants::SHIFTS[counter & 7]; + const uint8_t result = UnsafeNumericCast((temp & LeadingZeroBufferConstants::MASKS[counter & 7]) >> + LeadingZeroBufferConstants::SHIFTS[counter & 7]); counter++; return result; } @@ -303633,12 +306415,14 @@ class FlagBuffer { + + namespace duckdb { template struct BitUtils { static constexpr R Mask(unsigned int const bits) { - return (((uint64_t)(bits < (sizeof(R) * 8))) << (bits & ((sizeof(R) * 8) - 1))) - 1U; + return UnsafeNumericCast((((uint64_t)(bits < (sizeof(R) * 8))) << (bits & ((sizeof(R) * 8) - 1))) - 1U); } }; @@ -304083,7 +306867,7 @@ struct Chimp128Decompression { case ChimpConstants::Flags::VALUE_IDENTICAL: { //! Value is identical to previous value auto index = state.input.template ReadValue(); - result = state.ring_buffer.Value(index); + result = UnsafeNumericCast(state.ring_buffer.Value(index)); break; } case ChimpConstants::Flags::TRAILING_EXCEEDS_THRESHOLD: { @@ -304303,6 +307087,7 @@ void ChimpFinalizeCompress(CompressionState &state_p) { + namespace duckdb { @@ -304489,7 +307274,7 @@ struct ChimpScanState : public SegmentScanState { auto group_size = MinValue(segment_count - total_value_count, ChimpPrimitives::CHIMP_SEQUENCE_SIZE); // Reduce by one, because the first value of a group does not have a flag auto flag_count = group_size - 1; - uint16_t flag_byte_count = (AlignValue(flag_count) / 4); + uint16_t flag_byte_count = AlignValue(UnsafeNumericCast(flag_count)) / 4; // Load the flags metadata_ptr -= flag_byte_count; @@ -304687,6 +307472,7 @@ constexpr uint8_t LeadingZeroBufferConstants::SHIFTS[]; + namespace duckdb { // Abstract class for keeping compression state either for compression or size analysis @@ -304891,7 +307677,7 @@ struct DictionaryCompressionCompressState : public DictionaryCompressionState { // Update buffers and map index_buffer.push_back(current_dictionary.size); - selection_buffer.push_back(index_buffer.size() - 1); + selection_buffer.push_back(UnsafeNumericCast(index_buffer.size() - 1)); if (str.IsInlined()) { current_string_map.insert({str, index_buffer.size() - 1}); } else { @@ -304964,8 +307750,8 @@ struct DictionaryCompressionCompressState : public DictionaryCompressionState { memcpy(base_ptr + index_buffer_offset, index_buffer.data(), index_buffer_size); // Store sizes and offsets in segment header - Store(index_buffer_offset, data_ptr_cast(&header_ptr->index_buffer_offset)); - Store(index_buffer.size(), data_ptr_cast(&header_ptr->index_buffer_count)); + Store(NumericCast(index_buffer_offset), data_ptr_cast(&header_ptr->index_buffer_offset)); + Store(NumericCast(index_buffer.size()), data_ptr_cast(&header_ptr->index_buffer_count)); Store((uint32_t)current_width, data_ptr_cast(&header_ptr->bitpacking_width)); D_ASSERT(current_width == BitpackingPrimitives::MinimumBitWidth(index_buffer.size() - 1)); @@ -305186,7 +307972,7 @@ void DictionaryCompressionStorage::StringScanPartial(ColumnSegment &segment, Col // Lookup dict offset in index buffer auto string_number = scan_state.sel_vec->get_index(i + start_offset); auto dict_offset = index_buffer_ptr[string_number]; - uint16_t str_len = GetStringLength(index_buffer_ptr, string_number); + auto str_len = GetStringLength(index_buffer_ptr, UnsafeNumericCast(string_number)); result_data[result_offset + i] = FetchStringFromDict(segment, dict, baseptr, dict_offset, str_len); } @@ -305306,7 +308092,7 @@ uint16_t DictionaryCompressionStorage::GetStringLength(uint32_t *index_buffer_pt if (index == 0) { return 0; } else { - return index_buffer_ptr[index] - index_buffer_ptr[index - 1]; + return UnsafeNumericCast(index_buffer_ptr[index] - index_buffer_ptr[index - 1]); } } @@ -305880,7 +308666,7 @@ class FSSTCompressionState : public CompressionState { current_dictionary.Verify(); // We just push the string length to effectively delta encode the strings - index_buffer.push_back(compressed_string_len); + index_buffer.push_back(NumericCast(compressed_string_len)); max_compressed_string_length = MaxValue(max_compressed_string_length, compressed_string_len); @@ -305979,7 +308765,8 @@ class FSSTCompressionState : public CompressionState { memset(base_ptr + symbol_table_offset, 0, fsst_serialized_symbol_table_size); } - Store(symbol_table_offset, data_ptr_cast(&header_ptr->fsst_symbol_table_offset)); + Store(NumericCast(symbol_table_offset), + data_ptr_cast(&header_ptr->fsst_symbol_table_offset)); Store((uint32_t)current_width, data_ptr_cast(&header_ptr->bitpacking_width)); if (total_size >= FSSTStorage::COMPACTION_FLUSH_LIMIT) { @@ -307239,7 +310026,7 @@ struct RLEScanState : public SegmentScanState { handle = buffer_manager.Pin(segment.block); entry_pos = 0; position_in_entry = 0; - rle_count_offset = Load(handle.Ptr() + segment.GetBlockOffset()); + rle_count_offset = UnsafeNumericCast(Load(handle.Ptr() + segment.GetBlockOffset())); D_ASSERT(rle_count_offset <= Storage::BLOCK_SIZE); } @@ -307609,7 +310396,7 @@ UncompressedStringStorage::StringInitSegment(ColumnSegment &segment, block_id_t auto handle = buffer_manager.Pin(segment.block); StringDictionaryContainer dictionary; dictionary.size = 0; - dictionary.end = segment.SegmentSize(); + dictionary.end = UnsafeNumericCast(segment.SegmentSize()); SetDictionary(segment, handle, dictionary); } auto result = make_uniq(); @@ -307728,7 +310515,7 @@ void UncompressedStringStorage::WriteString(ColumnSegment &segment, string_t str void UncompressedStringStorage::WriteStringMemory(ColumnSegment &segment, string_t string, block_id_t &result_block, int32_t &result_offset) { - uint32_t total_length = string.GetSize() + sizeof(uint32_t); + auto total_length = UnsafeNumericCast(string.GetSize() + sizeof(uint32_t)); shared_ptr block; BufferHandle handle; @@ -307754,11 +310541,11 @@ void UncompressedStringStorage::WriteStringMemory(ColumnSegment &segment, string } result_block = state.head->block->BlockId(); - result_offset = state.head->offset; + result_offset = UnsafeNumericCast(state.head->offset); // copy the string and the length there auto ptr = handle.Ptr() + state.head->offset; - Store(string.GetSize(), ptr); + Store(UnsafeNumericCast(string.GetSize()), ptr); ptr += sizeof(uint32_t); memcpy(ptr, string.GetData(), string.GetSize()); state.head->offset += total_length; @@ -308751,7 +311538,6 @@ bool DataTable::NextParallelScan(ClientContext &context, ParallelTableScanState if (row_groups->NextParallelScan(context, state.scan_state, scan_state.table_state)) { return true; } - scan_state.table_state.batch_index = state.scan_state.batch_index; auto &local_storage = LocalStorage::Get(context, db); if (local_storage.NextParallelScan(context, *this, state.local_state, scan_state.local_state)) { return true; @@ -309261,12 +312047,12 @@ void DataTable::AppendLock(TableAppendState &state) { state.current_row = state.row_start; } -void DataTable::InitializeAppend(DuckTransaction &transaction, TableAppendState &state, idx_t append_count) { +void DataTable::InitializeAppend(DuckTransaction &transaction, TableAppendState &state) { // obtain the append lock for this table if (!state.append_lock) { throw InternalException("DataTable::AppendLock should be called before DataTable::InitializeAppend"); } - row_groups->InitializeAppend(transaction, state, append_count); + row_groups->InitializeAppend(transaction, state); } void DataTable::Append(DataChunk &chunk, TableAppendState &state) { @@ -309274,6 +312060,10 @@ void DataTable::Append(DataChunk &chunk, TableAppendState &state) { row_groups->Append(chunk, state); } +void DataTable::FinalizeAppend(DuckTransaction &transaction, TableAppendState &state) { + row_groups->FinalizeAppend(transaction, state); +} + void DataTable::ScanTableSegment(idx_t row_start, idx_t count, const std::function &function) { if (count == 0) { return; @@ -310060,7 +312850,7 @@ void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppen idx_t append_count, bool append_to_table) { auto &table = table_ref.get(); if (append_to_table) { - table.InitializeAppend(transaction, append_state, append_count); + table.InitializeAppend(transaction, append_state); } ErrorData error; if (append_to_table) { @@ -310111,6 +312901,9 @@ void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppen }); error.Throw(); } + if (append_to_table) { + table.FinalizeAppend(transaction, append_state); + } } OptimisticDataWriter &LocalTableStorage::CreateOptimisticWriter() { @@ -310261,7 +313054,7 @@ bool LocalStorage::NextParallelScan(ClientContext &context, DataTable &table, Pa void LocalStorage::InitializeAppend(LocalAppendState &state, DataTable &table) { state.storage = &table_manager.GetOrCreateStorage(table); - state.storage->row_groups->InitializeAppend(TransactionData(transaction), state.append_state, 0); + state.storage->row_groups->InitializeAppend(TransactionData(transaction), state.append_state); } void LocalStorage::Append(LocalAppendState &state, DataChunk &chunk) { @@ -310612,7 +313405,7 @@ block_id_t MetadataManager::AllocateNewBlock() { auto handle = buffer_manager.Allocate(MemoryTag::METADATA, Storage::BLOCK_SIZE, false, &new_block.block); new_block.block_id = new_block_id; for (idx_t i = 0; i < METADATA_BLOCK_COUNT; i++) { - new_block.free_blocks.push_back(METADATA_BLOCK_COUNT - i - 1); + new_block.free_blocks.push_back(NumericCast(METADATA_BLOCK_COUNT - i - 1)); } // zero-initialize the handle memset(handle.Ptr(), 0, Storage::BLOCK_SIZE); @@ -310662,7 +313455,7 @@ MetadataPointer MetadataManager::FromDiskPointer(MetaBlockPointer pointer) { } // LCOV_EXCL_STOP MetadataPointer result; result.block_index = block_id; - result.index = index; + result.index = UnsafeNumericCast(index); return result; } @@ -310692,7 +313485,7 @@ MetaBlockPointer MetadataManager::FromBlockPointer(BlockPointer block_pointer) { D_ASSERT(offset < MetadataManager::METADATA_BLOCK_SIZE); MetaBlockPointer result; result.block_pointer = idx_t(block_pointer.block_id) | index << 56ULL; - result.offset = offset; + result.offset = UnsafeNumericCast(offset); return result; } @@ -310774,7 +313567,7 @@ void MetadataBlock::FreeBlocksFromInteger(idx_t free_list) { auto index = i - 1; idx_t mask = idx_t(1) << index; if (free_list & mask) { - free_blocks.push_back(index); + free_blocks.push_back(UnsafeNumericCast(index)); } } } @@ -310896,7 +313689,7 @@ void MetadataReader::ReadData(data_ptr_t buffer, idx_t read_size) { } MetaBlockPointer MetadataReader::GetMetaBlockPointer() { - return manager.GetDiskPointer(block.pointer, offset); + return manager.GetDiskPointer(block.pointer, UnsafeNumericCast(offset)); } void MetadataReader::ReadNextBlock() { @@ -310965,7 +313758,7 @@ MetaBlockPointer MetadataWriter::GetMetaBlockPointer() { NextBlock(); D_ASSERT(capacity > 0); } - return manager.GetDiskPointer(block.pointer, offset); + return manager.GetDiskPointer(block.pointer, UnsafeNumericCast(offset)); } MetadataHandle MetadataWriter::NextHandle() { @@ -311265,7 +314058,7 @@ void PartialBlockManager::Merge(PartialBlockManager &other) { if (!e.second) { throw InternalException("Empty partially filled block found"); } - auto used_space = Storage::BLOCK_SIZE - e.first; + auto used_space = NumericCast(Storage::BLOCK_SIZE - e.first); if (HasBlockAllocation(used_space)) { // we can merge this block into an existing block - merge them // merge blocks @@ -311605,6 +314398,7 @@ void CreateViewInfo::Serialize(Serializer &serializer) const { serializer.WritePropertyWithDefault>(202, "types", types); serializer.WritePropertyWithDefault>(203, "query", query); serializer.WritePropertyWithDefault>(204, "names", names); + serializer.WritePropertyWithDefault>(205, "column_comments", column_comments, vector()); } unique_ptr CreateViewInfo::Deserialize(Deserializer &deserializer) { @@ -311614,6 +314408,7 @@ unique_ptr CreateViewInfo::Deserialize(Deserializer &deserializer) { deserializer.ReadPropertyWithDefault>(202, "types", result->types); deserializer.ReadPropertyWithDefault>(203, "query", result->query); deserializer.ReadPropertyWithDefault>(204, "names", result->names); + deserializer.ReadPropertyWithDefault>(205, "column_comments", result->column_comments, vector()); return std::move(result); } @@ -311633,12 +314428,14 @@ void Expression::Serialize(Serializer &serializer) const { serializer.WriteProperty(100, "expression_class", expression_class); serializer.WriteProperty(101, "type", type); serializer.WritePropertyWithDefault(102, "alias", alias); + serializer.WritePropertyWithDefault(103, "query_location", query_location, optional_idx()); } unique_ptr Expression::Deserialize(Deserializer &deserializer) { auto expression_class = deserializer.ReadProperty(100, "expression_class"); auto type = deserializer.ReadProperty(101, "type"); auto alias = deserializer.ReadPropertyWithDefault(102, "alias"); + auto query_location = deserializer.ReadPropertyWithDefault(103, "query_location", optional_idx()); deserializer.Set(type); unique_ptr result; switch (expression_class) { @@ -311698,6 +314495,7 @@ unique_ptr Expression::Deserialize(Deserializer &deserializer) { } deserializer.Unset(); result->alias = std::move(alias); + result->query_location = query_location; return result; } @@ -312069,9 +314867,6 @@ unique_ptr LogicalOperator::Deserialize(Deserializer &deseriali case LogicalOperatorType::LOGICAL_LIMIT: result = LogicalLimit::Deserialize(deserializer); break; - case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: - result = LogicalLimitPercent::Deserialize(deserializer); - break; case LogicalOperatorType::LOGICAL_LOAD: result = LogicalSimple::Deserialize(deserializer); break; @@ -312451,35 +315246,14 @@ unique_ptr LogicalInsert::Deserialize(Deserializer &deserialize void LogicalLimit::Serialize(Serializer &serializer) const { LogicalOperator::Serialize(serializer); - serializer.WritePropertyWithDefault(200, "limit_val", limit_val); - serializer.WritePropertyWithDefault(201, "offset_val", offset_val); - serializer.WritePropertyWithDefault>(202, "limit", limit); - serializer.WritePropertyWithDefault>(203, "offset", offset); + serializer.WriteProperty(200, "limit_val", limit_val); + serializer.WriteProperty(201, "offset_val", offset_val); } unique_ptr LogicalLimit::Deserialize(Deserializer &deserializer) { - auto limit_val = deserializer.ReadPropertyWithDefault(200, "limit_val"); - auto offset_val = deserializer.ReadPropertyWithDefault(201, "offset_val"); - auto limit = deserializer.ReadPropertyWithDefault>(202, "limit"); - auto offset = deserializer.ReadPropertyWithDefault>(203, "offset"); - auto result = duckdb::unique_ptr(new LogicalLimit(limit_val, offset_val, std::move(limit), std::move(offset))); - return std::move(result); -} - -void LogicalLimitPercent::Serialize(Serializer &serializer) const { - LogicalOperator::Serialize(serializer); - serializer.WriteProperty(200, "limit_percent", limit_percent); - serializer.WritePropertyWithDefault(201, "offset_val", offset_val); - serializer.WritePropertyWithDefault>(202, "limit", limit); - serializer.WritePropertyWithDefault>(203, "offset", offset); -} - -unique_ptr LogicalLimitPercent::Deserialize(Deserializer &deserializer) { - auto limit_percent = deserializer.ReadProperty(200, "limit_percent"); - auto offset_val = deserializer.ReadPropertyWithDefault(201, "offset_val"); - auto limit = deserializer.ReadPropertyWithDefault>(202, "limit"); - auto offset = deserializer.ReadPropertyWithDefault>(203, "offset"); - auto result = duckdb::unique_ptr(new LogicalLimitPercent(limit_percent, offset_val, std::move(limit), std::move(offset))); + auto limit_val = deserializer.ReadProperty(200, "limit_val"); + auto offset_val = deserializer.ReadProperty(201, "offset_val"); + auto result = duckdb::unique_ptr(new LogicalLimit(std::move(limit_val), std::move(offset_val))); return std::move(result); } @@ -312804,6 +315578,22 @@ BoundCaseCheck BoundCaseCheck::Deserialize(Deserializer &deserializer) { return result; } +void BoundLimitNode::Serialize(Serializer &serializer) const { + serializer.WriteProperty(100, "type", type); + serializer.WritePropertyWithDefault(101, "constant_integer", constant_integer); + serializer.WriteProperty(102, "constant_percentage", constant_percentage); + serializer.WritePropertyWithDefault>(103, "expression", expression); +} + +BoundLimitNode BoundLimitNode::Deserialize(Deserializer &deserializer) { + auto type = deserializer.ReadProperty(100, "type"); + auto constant_integer = deserializer.ReadPropertyWithDefault(101, "constant_integer"); + auto constant_percentage = deserializer.ReadProperty(102, "constant_percentage"); + auto expression = deserializer.ReadPropertyWithDefault>(103, "expression"); + BoundLimitNode result(type, constant_integer, constant_percentage, std::move(expression)); + return result; +} + void BoundOrderByNode::Serialize(Serializer &serializer) const { serializer.WriteProperty(100, "type", type); serializer.WriteProperty(101, "null_order", null_order); @@ -312892,6 +315682,7 @@ void CSVReaderOptions::Serialize(Serializer &serializer) const { serializer.WriteProperty>>(128, "dialect_options.date_format", dialect_options.date_format); serializer.WritePropertyWithDefault(129, "sniffer_user_mismatch_error", sniffer_user_mismatch_error); serializer.WritePropertyWithDefault(130, "parallel", parallel); + serializer.WritePropertyWithDefault>(131, "was_type_manually_set", was_type_manually_set); } CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) { @@ -312927,6 +315718,7 @@ CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) { deserializer.ReadProperty>>(128, "dialect_options.date_format", result.dialect_options.date_format); deserializer.ReadPropertyWithDefault(129, "sniffer_user_mismatch_error", result.sniffer_user_mismatch_error); deserializer.ReadPropertyWithDefault(130, "parallel", result.parallel); + deserializer.ReadPropertyWithDefault>(131, "was_type_manually_set", result.was_type_manually_set); return result; } @@ -313122,14 +315914,14 @@ PivotColumn PivotColumn::Deserialize(Deserializer &deserializer) { void PivotColumnEntry::Serialize(Serializer &serializer) const { serializer.WritePropertyWithDefault>(100, "values", values); - serializer.WritePropertyWithDefault>(101, "star_expr", star_expr); + serializer.WritePropertyWithDefault>(101, "star_expr", expr); serializer.WritePropertyWithDefault(102, "alias", alias); } PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &deserializer) { PivotColumnEntry result; deserializer.ReadPropertyWithDefault>(100, "values", result.values); - deserializer.ReadPropertyWithDefault>(101, "star_expr", result.star_expr); + deserializer.ReadPropertyWithDefault>(101, "star_expr", result.expr); deserializer.ReadPropertyWithDefault(102, "alias", result.alias); return result; } @@ -313259,9 +316051,6 @@ unique_ptr ParseInfo::Deserialize(Deserializer &deserializer) { case ParseInfoType::ATTACH_INFO: result = AttachInfo::Deserialize(deserializer); break; - case ParseInfoType::COMMENT_ON_INFO: - result = CommentOnInfo::Deserialize(deserializer); - break; case ParseInfoType::COPY_INFO: result = CopyInfo::Deserialize(deserializer); break; @@ -313314,6 +316103,9 @@ unique_ptr AlterInfo::Deserialize(Deserializer &deserializer) { case AlterType::ALTER_VIEW: result = AlterViewInfo::Deserialize(deserializer); break; + case AlterType::SET_COLUMN_COMMENT: + result = SetColumnCommentInfo::Deserialize(deserializer); + break; case AlterType::SET_COMMENT: result = SetCommentInfo::Deserialize(deserializer); break; @@ -313358,9 +316150,6 @@ unique_ptr AlterTableInfo::Deserialize(Deserializer &deserializer) { case AlterTableType::RENAME_TABLE: result = RenameTableInfo::Deserialize(deserializer); break; - case AlterTableType::SET_COLUMN_COMMENT: - result = SetColumnCommentInfo::Deserialize(deserializer); - break; case AlterTableType::SET_DEFAULT: result = SetDefaultInfo::Deserialize(deserializer); break; @@ -313457,25 +316246,6 @@ unique_ptr ChangeColumnTypeInfo::Deserialize(Deserializer &deser return std::move(result); } -void CommentOnInfo::Serialize(Serializer &serializer) const { - ParseInfo::Serialize(serializer); - serializer.WriteProperty(200, "type", type); - serializer.WritePropertyWithDefault(201, "catalog", catalog); - serializer.WritePropertyWithDefault(202, "schema", schema); - serializer.WritePropertyWithDefault(203, "name", name); - serializer.WriteProperty(204, "comment", comment); -} - -unique_ptr CommentOnInfo::Deserialize(Deserializer &deserializer) { - auto result = duckdb::unique_ptr(new CommentOnInfo()); - deserializer.ReadProperty(200, "type", result->type); - deserializer.ReadPropertyWithDefault(201, "catalog", result->catalog); - deserializer.ReadPropertyWithDefault(202, "schema", result->schema); - deserializer.ReadPropertyWithDefault(203, "name", result->name); - deserializer.ReadProperty(204, "comment", result->comment); - return std::move(result); -} - void CopyInfo::Serialize(Serializer &serializer) const { ParseInfo::Serialize(serializer); serializer.WritePropertyWithDefault(200, "catalog", catalog); @@ -313631,15 +316401,17 @@ unique_ptr RenameViewInfo::Deserialize(Deserializer &deserializer } void SetColumnCommentInfo::Serialize(Serializer &serializer) const { - AlterTableInfo::Serialize(serializer); - serializer.WritePropertyWithDefault(400, "column_name", column_name); - serializer.WriteProperty(401, "comment", comment); + AlterInfo::Serialize(serializer); + serializer.WriteProperty(300, "catalog_entry_type", catalog_entry_type); + serializer.WriteProperty(301, "comment_value", comment_value); + serializer.WritePropertyWithDefault(302, "column_name", column_name); } -unique_ptr SetColumnCommentInfo::Deserialize(Deserializer &deserializer) { +unique_ptr SetColumnCommentInfo::Deserialize(Deserializer &deserializer) { auto result = duckdb::unique_ptr(new SetColumnCommentInfo()); - deserializer.ReadPropertyWithDefault(400, "column_name", result->column_name); - deserializer.ReadProperty(401, "comment", result->comment); + deserializer.ReadProperty(300, "catalog_entry_type", result->catalog_entry_type); + deserializer.ReadProperty(301, "comment_value", result->comment_value); + deserializer.ReadPropertyWithDefault(302, "column_name", result->column_name); return std::move(result); } @@ -315644,6 +318416,176 @@ class InMemoryBlockManager : public BlockManager { +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/storage/temporary_file_manager.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + + + + + + + + +namespace duckdb { + +//===--------------------------------------------------------------------===// +// BlockIndexManager +//===--------------------------------------------------------------------===// + +struct BlockIndexManager { +public: + BlockIndexManager(); + +public: + //! Obtains a new block index from the index manager + idx_t GetNewBlockIndex(); + //! Removes an index from the block manager + //! Returns true if the max_index has been altered + bool RemoveIndex(idx_t index); + idx_t GetMaxIndex(); + bool HasFreeBlocks(); + +private: + idx_t GetNewBlockIndexInternal(); + +private: + idx_t max_index; + set free_indexes; + set indexes_in_use; +}; + +//===--------------------------------------------------------------------===// +// TemporaryFileIndex +//===--------------------------------------------------------------------===// + +// FIXME: should be optional_idx +struct TemporaryFileIndex { + explicit TemporaryFileIndex(idx_t file_index = DConstants::INVALID_INDEX, + idx_t block_index = DConstants::INVALID_INDEX); + + idx_t file_index; + idx_t block_index; + +public: + bool IsValid() const; +}; + +//===--------------------------------------------------------------------===// +// TemporaryFileHandle +//===--------------------------------------------------------------------===// + +class TemporaryFileHandle { + constexpr static idx_t MAX_ALLOWED_INDEX_BASE = 4000; + +public: + TemporaryFileHandle(idx_t temp_file_count, DatabaseInstance &db, const string &temp_directory, idx_t index); + +public: + struct TemporaryFileLock { + public: + explicit TemporaryFileLock(mutex &mutex); + + public: + lock_guard lock; + }; + +public: + TemporaryFileIndex TryGetBlockIndex(); + void WriteTemporaryFile(FileBuffer &buffer, TemporaryFileIndex index); + unique_ptr ReadTemporaryBuffer(idx_t block_index, unique_ptr reusable_buffer); + void EraseBlockIndex(block_id_t block_index); + bool DeleteIfEmpty(); + TemporaryFileInformation GetTemporaryFile(); + +private: + void CreateFileIfNotExists(TemporaryFileLock &); + void RemoveTempBlockIndex(TemporaryFileLock &, idx_t index); + idx_t GetPositionInFile(idx_t index); + +private: + const idx_t max_allowed_index; + DatabaseInstance &db; + unique_ptr handle; + idx_t file_index; + string path; + mutex file_lock; + BlockIndexManager index_manager; +}; + +class TemporaryFileManager; + +//===--------------------------------------------------------------------===// +// TemporaryDirectoryHandle +//===--------------------------------------------------------------------===// + +class TemporaryDirectoryHandle { +public: + TemporaryDirectoryHandle(DatabaseInstance &db, string path_p); + ~TemporaryDirectoryHandle(); + + TemporaryFileManager &GetTempFile(); + +private: + DatabaseInstance &db; + string temp_directory; + bool created_directory = false; + unique_ptr temp_file; +}; + +//===--------------------------------------------------------------------===// +// TemporaryFileManager +//===--------------------------------------------------------------------===// + +class TemporaryFileManager { +public: + TemporaryFileManager(DatabaseInstance &db, const string &temp_directory_p); + +public: + struct TemporaryManagerLock { + public: + explicit TemporaryManagerLock(mutex &mutex); + + public: + lock_guard lock; + }; + + void WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer); + bool HasTemporaryBuffer(block_id_t block_id); + unique_ptr ReadTemporaryBuffer(block_id_t id, unique_ptr reusable_buffer); + void DeleteTemporaryBuffer(block_id_t id); + vector GetTemporaryFiles(); + +private: + void EraseUsedBlock(TemporaryManagerLock &lock, block_id_t id, TemporaryFileHandle *handle, + TemporaryFileIndex index); + TemporaryFileHandle *GetFileHandle(TemporaryManagerLock &, idx_t index); + TemporaryFileIndex GetTempBlockIndex(TemporaryManagerLock &, block_id_t id); + void EraseFileHandle(TemporaryManagerLock &, idx_t file_index); + +private: + DatabaseInstance &db; + mutex manager_lock; + //! The temporary directory + string temp_directory; + //! The set of active temporary file handles + unordered_map> files; + //! map of block_id -> temporary file position + unordered_map used_blocks; + //! Manager of in-use temporary file indexes + BlockIndexManager index_manager; +}; + +} // namespace duckdb + namespace duckdb { @@ -315669,22 +318611,6 @@ unique_ptr StandardBufferManager::ConstructManagedBuffer(idx_t size, return result; } -class TemporaryFileManager; - -class TemporaryDirectoryHandle { -public: - TemporaryDirectoryHandle(DatabaseInstance &db, string path_p); - ~TemporaryDirectoryHandle(); - - TemporaryFileManager &GetTempFile(); - -private: - DatabaseInstance &db; - string temp_directory; - bool created_directory = false; - unique_ptr temp_file; -}; - void StandardBufferManager::SetTemporaryDirectory(const string &new_dir) { if (temp_directory_handle) { throw NotImplementedException("Cannot switch temporary directory after the current one has been used"); @@ -315770,22 +318696,26 @@ BufferHandle StandardBufferManager::Allocate(MemoryTag tag, idx_t block_size, bo void StandardBufferManager::ReAllocate(shared_ptr &handle, idx_t block_size) { D_ASSERT(block_size >= Storage::BLOCK_SIZE); - lock_guard lock(handle->lock); + unique_lock lock(handle->lock); D_ASSERT(handle->state == BlockState::BLOCK_LOADED); D_ASSERT(handle->memory_usage == handle->buffer->AllocSize()); D_ASSERT(handle->memory_usage == handle->memory_charge.size); auto req = handle->buffer->CalculateMemory(block_size); - int64_t memory_delta = (int64_t)req.alloc_size - handle->memory_usage; + int64_t memory_delta = NumericCast(req.alloc_size) - handle->memory_usage; if (memory_delta == 0) { return; } else if (memory_delta > 0) { // evict blocks until we have space to resize this block + // unlock the handle lock during the call to EvictBlocksOrThrow + lock.unlock(); auto reservation = EvictBlocksOrThrow(handle->tag, memory_delta, nullptr, "failed to resize block from %s to %s%s", StringUtil::BytesToHumanReadableString(handle->memory_usage), StringUtil::BytesToHumanReadableString(req.alloc_size)); + lock.lock(); + // EvictBlocks decrements 'current_memory' for us. handle->memory_charge.Merge(std::move(reservation)); } else { @@ -315814,7 +318744,7 @@ BufferHandle StandardBufferManager::Pin(shared_ptr &handle) { auto reservation = EvictBlocksOrThrow(handle->tag, required_memory, &reusable_buffer, "failed to pin block of size %s%s", StringUtil::BytesToHumanReadableString(required_memory)); - // lock the handle again and repeat the check (in case anybody loaded in the mean time) + // lock the handle again and repeat the check (in case anybody loaded in the meantime) lock_guard lock(handle->lock); // check if the block is already loaded if (handle->state == BlockState::BLOCK_LOADED) { @@ -315858,15 +318788,23 @@ void StandardBufferManager::VerifyZeroReaders(shared_ptr &handle) { } void StandardBufferManager::Unpin(shared_ptr &handle) { - lock_guard lock(handle->lock); - if (!handle->buffer || handle->buffer->type == FileBufferType::TINY_BUFFER) { - return; + bool purge = false; + { + lock_guard lock(handle->lock); + if (!handle->buffer || handle->buffer->type == FileBufferType::TINY_BUFFER) { + return; + } + D_ASSERT(handle->readers > 0); + handle->readers--; + if (handle->readers == 0) { + VerifyZeroReaders(handle); + purge = buffer_pool.AddToEvictionQueue(handle); + } } - D_ASSERT(handle->readers > 0); - handle->readers--; - if (handle->readers == 0) { - VerifyZeroReaders(handle); - buffer_pool.AddToEvictionQueue(handle); + + // We do not have to keep the handle locked while purging. + if (purge) { + PurgeQueue(); } } @@ -315886,379 +318824,15 @@ vector StandardBufferManager::GetMemoryUsageInfo() const { return result; } -//===--------------------------------------------------------------------===// -// Temporary File Management -//===--------------------------------------------------------------------===// -unique_ptr ReadTemporaryBufferInternal(BufferManager &buffer_manager, FileHandle &handle, idx_t position, - idx_t size, block_id_t id, unique_ptr reusable_buffer) { +unique_ptr StandardBufferManager::ReadTemporaryBufferInternal(BufferManager &buffer_manager, + FileHandle &handle, idx_t position, + idx_t size, + unique_ptr reusable_buffer) { auto buffer = buffer_manager.ConstructManagedBuffer(size, std::move(reusable_buffer)); buffer->Read(handle, position); return buffer; } -struct TemporaryFileIndex { - explicit TemporaryFileIndex(idx_t file_index = DConstants::INVALID_INDEX, - idx_t block_index = DConstants::INVALID_INDEX) - : file_index(file_index), block_index(block_index) { - } - - idx_t file_index; - idx_t block_index; - -public: - bool IsValid() { - return block_index != DConstants::INVALID_INDEX; - } -}; - -struct BlockIndexManager { - BlockIndexManager() : max_index(0) { - } - -public: - //! Obtains a new block index from the index manager - idx_t GetNewBlockIndex() { - auto index = GetNewBlockIndexInternal(); - indexes_in_use.insert(index); - return index; - } - - //! Removes an index from the block manager - //! Returns true if the max_index has been altered - bool RemoveIndex(idx_t index) { - // remove this block from the set of blocks - auto entry = indexes_in_use.find(index); - if (entry == indexes_in_use.end()) { - throw InternalException("RemoveIndex - index %llu not found in indexes_in_use", index); - } - indexes_in_use.erase(entry); - free_indexes.insert(index); - // check if we can truncate the file - - // get the max_index in use right now - auto max_index_in_use = indexes_in_use.empty() ? 0 : *indexes_in_use.rbegin(); - if (max_index_in_use < max_index) { - // max index in use is lower than the max_index - // reduce the max_index - max_index = indexes_in_use.empty() ? 0 : max_index_in_use + 1; - // we can remove any free_indexes that are larger than the current max_index - while (!free_indexes.empty()) { - auto max_entry = *free_indexes.rbegin(); - if (max_entry < max_index) { - break; - } - free_indexes.erase(max_entry); - } - return true; - } - return false; - } - - idx_t GetMaxIndex() { - return max_index; - } - - bool HasFreeBlocks() { - return !free_indexes.empty(); - } - -private: - idx_t GetNewBlockIndexInternal() { - if (free_indexes.empty()) { - return max_index++; - } - auto entry = free_indexes.begin(); - auto index = *entry; - free_indexes.erase(entry); - return index; - } - - idx_t max_index; - set free_indexes; - set indexes_in_use; -}; - -class TemporaryFileHandle { - constexpr static idx_t MAX_ALLOWED_INDEX_BASE = 4000; - -public: - TemporaryFileHandle(idx_t temp_file_count, DatabaseInstance &db, const string &temp_directory, idx_t index) - : max_allowed_index((1 << temp_file_count) * MAX_ALLOWED_INDEX_BASE), db(db), file_index(index), - path(FileSystem::GetFileSystem(db).JoinPath(temp_directory, - "duckdb_temp_storage-" + to_string(index) + ".tmp")) { - } - -public: - struct TemporaryFileLock { - explicit TemporaryFileLock(mutex &mutex) : lock(mutex) { - } - - lock_guard lock; - }; - -public: - TemporaryFileIndex TryGetBlockIndex() { - TemporaryFileLock lock(file_lock); - if (index_manager.GetMaxIndex() >= max_allowed_index && index_manager.HasFreeBlocks()) { - // file is at capacity - return TemporaryFileIndex(); - } - // open the file handle if it does not yet exist - CreateFileIfNotExists(lock); - // fetch a new block index to write to - auto block_index = index_manager.GetNewBlockIndex(); - return TemporaryFileIndex(file_index, block_index); - } - - void WriteTemporaryFile(FileBuffer &buffer, TemporaryFileIndex index) { - D_ASSERT(buffer.size == Storage::BLOCK_SIZE); - buffer.Write(*handle, GetPositionInFile(index.block_index)); - } - - unique_ptr ReadTemporaryBuffer(block_id_t id, idx_t block_index, - unique_ptr reusable_buffer) { - return ReadTemporaryBufferInternal(BufferManager::GetBufferManager(db), *handle, GetPositionInFile(block_index), - Storage::BLOCK_SIZE, id, std::move(reusable_buffer)); - } - - void EraseBlockIndex(block_id_t block_index) { - // remove the block (and potentially truncate the temp file) - TemporaryFileLock lock(file_lock); - D_ASSERT(handle); - RemoveTempBlockIndex(lock, block_index); - } - - bool DeleteIfEmpty() { - TemporaryFileLock lock(file_lock); - if (index_manager.GetMaxIndex() > 0) { - // there are still blocks in this file - return false; - } - // the file is empty: delete it - handle.reset(); - auto &fs = FileSystem::GetFileSystem(db); - fs.RemoveFile(path); - return true; - } - - TemporaryFileInformation GetTemporaryFile() { - TemporaryFileLock lock(file_lock); - TemporaryFileInformation info; - info.path = path; - info.size = GetPositionInFile(index_manager.GetMaxIndex()); - return info; - } - -private: - void CreateFileIfNotExists(TemporaryFileLock &) { - if (handle) { - return; - } - auto &fs = FileSystem::GetFileSystem(db); - handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ | FileFlags::FILE_FLAGS_WRITE | - FileFlags::FILE_FLAGS_FILE_CREATE); - } - - void RemoveTempBlockIndex(TemporaryFileLock &, idx_t index) { - // remove the block index from the index manager - if (index_manager.RemoveIndex(index)) { - // the max_index that is currently in use has decreased - // as a result we can truncate the file -#ifndef WIN32 // this ended up causing issues when sorting - auto max_index = index_manager.GetMaxIndex(); - auto &fs = FileSystem::GetFileSystem(db); - fs.Truncate(*handle, GetPositionInFile(max_index + 1)); -#endif - } - } - - idx_t GetPositionInFile(idx_t index) { - return index * Storage::BLOCK_ALLOC_SIZE; - } - -private: - const idx_t max_allowed_index; - DatabaseInstance &db; - unique_ptr handle; - idx_t file_index; - string path; - mutex file_lock; - BlockIndexManager index_manager; -}; - -class TemporaryFileManager { -public: - TemporaryFileManager(DatabaseInstance &db, const string &temp_directory_p) - : db(db), temp_directory(temp_directory_p) { - } - -public: - struct TemporaryManagerLock { - explicit TemporaryManagerLock(mutex &mutex) : lock(mutex) { - } - - lock_guard lock; - }; - - void WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer) { - D_ASSERT(buffer.size == Storage::BLOCK_SIZE); - TemporaryFileIndex index; - TemporaryFileHandle *handle = nullptr; - - { - TemporaryManagerLock lock(manager_lock); - // first check if we can write to an open existing file - for (auto &entry : files) { - auto &temp_file = entry.second; - index = temp_file->TryGetBlockIndex(); - if (index.IsValid()) { - handle = entry.second.get(); - break; - } - } - if (!handle) { - // no existing handle to write to; we need to create & open a new file - auto new_file_index = index_manager.GetNewBlockIndex(); - auto new_file = make_uniq(files.size(), db, temp_directory, new_file_index); - handle = new_file.get(); - files[new_file_index] = std::move(new_file); - - index = handle->TryGetBlockIndex(); - } - D_ASSERT(used_blocks.find(block_id) == used_blocks.end()); - used_blocks[block_id] = index; - } - D_ASSERT(handle); - D_ASSERT(index.IsValid()); - handle->WriteTemporaryFile(buffer, index); - } - - bool HasTemporaryBuffer(block_id_t block_id) { - lock_guard lock(manager_lock); - return used_blocks.find(block_id) != used_blocks.end(); - } - - unique_ptr ReadTemporaryBuffer(block_id_t id, unique_ptr reusable_buffer) { - TemporaryFileIndex index; - TemporaryFileHandle *handle; - { - TemporaryManagerLock lock(manager_lock); - index = GetTempBlockIndex(lock, id); - handle = GetFileHandle(lock, index.file_index); - } - auto buffer = handle->ReadTemporaryBuffer(id, index.block_index, std::move(reusable_buffer)); - { - // remove the block (and potentially erase the temp file) - TemporaryManagerLock lock(manager_lock); - EraseUsedBlock(lock, id, handle, index); - } - return buffer; - } - - void DeleteTemporaryBuffer(block_id_t id) { - TemporaryManagerLock lock(manager_lock); - auto index = GetTempBlockIndex(lock, id); - auto handle = GetFileHandle(lock, index.file_index); - EraseUsedBlock(lock, id, handle, index); - } - - vector GetTemporaryFiles() { - lock_guard lock(manager_lock); - vector result; - for (auto &file : files) { - result.push_back(file.second->GetTemporaryFile()); - } - return result; - } - -private: - void EraseUsedBlock(TemporaryManagerLock &lock, block_id_t id, TemporaryFileHandle *handle, - TemporaryFileIndex index) { - auto entry = used_blocks.find(id); - if (entry == used_blocks.end()) { - throw InternalException("EraseUsedBlock - Block %llu not found in used blocks", id); - } - used_blocks.erase(entry); - handle->EraseBlockIndex(index.block_index); - if (handle->DeleteIfEmpty()) { - EraseFileHandle(lock, index.file_index); - } - } - - TemporaryFileHandle *GetFileHandle(TemporaryManagerLock &, idx_t index) { - return files[index].get(); - } - - TemporaryFileIndex GetTempBlockIndex(TemporaryManagerLock &, block_id_t id) { - D_ASSERT(used_blocks.find(id) != used_blocks.end()); - return used_blocks[id]; - } - - void EraseFileHandle(TemporaryManagerLock &, idx_t file_index) { - files.erase(file_index); - index_manager.RemoveIndex(file_index); - } - -private: - DatabaseInstance &db; - mutex manager_lock; - //! The temporary directory - string temp_directory; - //! The set of active temporary file handles - unordered_map> files; - //! map of block_id -> temporary file position - unordered_map used_blocks; - //! Manager of in-use temporary file indexes - BlockIndexManager index_manager; -}; - -TemporaryDirectoryHandle::TemporaryDirectoryHandle(DatabaseInstance &db, string path_p) - : db(db), temp_directory(std::move(path_p)), temp_file(make_uniq(db, temp_directory)) { - auto &fs = FileSystem::GetFileSystem(db); - if (!temp_directory.empty()) { - if (!fs.DirectoryExists(temp_directory)) { - fs.CreateDirectory(temp_directory); - created_directory = true; - } - } -} -TemporaryDirectoryHandle::~TemporaryDirectoryHandle() { - // first release any temporary files - temp_file.reset(); - // then delete the temporary file directory - auto &fs = FileSystem::GetFileSystem(db); - if (!temp_directory.empty()) { - bool delete_directory = created_directory; - vector files_to_delete; - if (!created_directory) { - bool deleted_everything = true; - fs.ListFiles(temp_directory, [&](const string &path, bool isdir) { - if (isdir) { - deleted_everything = false; - return; - } - if (!StringUtil::StartsWith(path, "duckdb_temp_")) { - deleted_everything = false; - return; - } - files_to_delete.push_back(path); - }); - } - if (delete_directory) { - // we want to remove all files in the directory - fs.RemoveDirectory(temp_directory); - } else { - for (auto &file : files_to_delete) { - fs.RemoveFile(fs.JoinPath(temp_directory, file)); - } - } - } -} - -TemporaryFileManager &TemporaryDirectoryHandle::GetTempFile() { - return *temp_file; -} - string StandardBufferManager::GetTemporaryPath(block_id_t id) { auto &fs = FileSystem::GetFileSystem(db); return fs.JoinPath(temp_directory, "duckdb_temp_block-" + to_string(id) + ".block"); @@ -316312,8 +318886,7 @@ unique_ptr StandardBufferManager::ReadTemporaryBuffer(MemoryTag tag, evicted_data_per_tag[uint8_t(tag)] -= block_size; // now allocate a buffer of this size and read the data into that buffer - auto buffer = - ReadTemporaryBufferInternal(*this, *handle, sizeof(idx_t), block_size, id, std::move(reusable_buffer)); + auto buffer = ReadTemporaryBufferInternal(*this, *handle, sizeof(idx_t), block_size, std::move(reusable_buffer)); handle.reset(); DeleteTemporaryFile(id); @@ -318247,7 +320820,7 @@ void StringStats::Update(BaseStatistics &stats, const string_t &value) { memcpy(string_data.max, target, StringStatsData::MAX_STRING_MINMAX_SIZE); } if (size > string_data.max_string_length) { - string_data.max_string_length = size; + string_data.max_string_length = UnsafeNumericCast(size); } if (stats.GetType().id() == LogicalTypeId::VARCHAR && !string_data.has_unicode) { auto unicode = Utf8Proc::Analyze(const_char_ptr_cast(data), size); @@ -318535,7 +321108,7 @@ struct StorageVersionInfo { idx_t storage_version; }; -static StorageVersionInfo storage_version_info[] = {{"v0.9.0, v0.9.1 or v0.9.2", 64}, +static StorageVersionInfo storage_version_info[] = {{"v0.9.0, v0.9.1, v0.9.2 or v0.10.0", 64}, {"v0.8.0 or v0.8.1", 51}, {"v0.7.0 or v0.7.1", 43}, {"v0.6.0 or v0.6.1", 39}, @@ -319576,7 +322149,6 @@ void PartialBlockForCheckpoint::Flush(const idx_t free_space_left) { for (idx_t i = 0; i < segments.size(); i++) { auto &segment = segments[i]; - segment.data.IncrementVersion(); if (i == 0) { // the first segment is converted to persistent - this writes the data for ALL segments to disk D_ASSERT(segment.offset_in_block == 0); @@ -319617,7 +322189,7 @@ void PartialBlockForCheckpoint::Merge(PartialBlock &other_p, idx_t offset, idx_t // move over the segments for (auto &segment : other.segments) { - AddSegmentToTail(segment.data, segment.segment, segment.offset_in_block + offset); + AddSegmentToTail(segment.data, segment.segment, NumericCast(segment.offset_in_block + offset)); } other.Clear(); @@ -319654,7 +322226,8 @@ void ColumnCheckpointState::FlushSegment(unique_ptr segment, idx_ partial_block_lock = partial_block_manager.GetLock(); // non-constant block - PartialBlockAllocation allocation = partial_block_manager.GetBlockAllocation(segment_size); + PartialBlockAllocation allocation = + partial_block_manager.GetBlockAllocation(NumericCast(segment_size)); block_id = allocation.state.block_id; offset_in_block = allocation.state.offset; @@ -319985,7 +322558,7 @@ namespace duckdb { ColumnData::ColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type_p, optional_ptr parent) : start(start_row), count(0), block_manager(block_manager), info(info), column_index(column_index), - type(std::move(type_p)), parent(parent), version(0) { + type(std::move(type_p)), parent(parent), allocation_size(0) { if (!parent) { stats = make_uniq(type); } @@ -320019,10 +322592,6 @@ const LogicalType &ColumnData::RootType() const { return type; } -void ColumnData::IncrementVersion() { - version++; -} - idx_t ColumnData::GetMaxEntry() { return count; } @@ -320033,7 +322602,6 @@ void ColumnData::InitializeScan(ColumnScanState &state) { state.row_index = state.current ? state.current->start : 0; state.internal_index = state.row_index; state.initialized = false; - state.version = version; state.scan_state.reset(); state.last_offset = 0; } @@ -320044,25 +322612,19 @@ void ColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) state.row_index = row_idx; state.internal_index = state.current->start; state.initialized = false; - state.version = version; state.scan_state.reset(); state.last_offset = 0; } idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remaining, bool has_updates) { state.previous_states.clear(); - if (state.version != version) { - InitializeScanWithOffset(state, state.row_index); - state.current->InitializeScan(state); - state.initialized = true; - } else if (!state.initialized) { + if (!state.initialized) { D_ASSERT(state.current); state.current->InitializeScan(state); state.internal_index = state.current->start; state.initialized = true; } D_ASSERT(data.HasSegment(state.current)); - D_ASSERT(state.version == version); D_ASSERT(state.internal_index <= state.row_index); if (state.internal_index < state.row_index) { state.current->Skip(state); @@ -320172,8 +322734,10 @@ idx_t ColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count) void ColumnData::Select(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result, SelectionVector &sel, idx_t &count, const TableFilter &filter) { idx_t scan_count = Scan(transaction, vector_index, state, result); - result.Flatten(scan_count); - ColumnSegment::FilterSelection(sel, result, filter, count, FlatVector::Validity(result)); + + UnifiedVectorFormat vdata; + result.ToUnifiedFormat(scan_count, vdata); + ColumnSegment::FilterSelection(sel, result, vdata, filter, scan_count, count); } void ColumnData::FilterScan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result, @@ -320368,6 +322932,7 @@ void ColumnData::AppendTransientSegment(SegmentLock &l, idx_t start_row) { // the segment size is bound by the block size, but can be smaller idx_t segment_size = Storage::BLOCK_SIZE < vector_segment_size ? Storage::BLOCK_SIZE : vector_segment_size; + allocation_size += segment_size; auto new_segment = ColumnSegment::CreateTransientSegment(GetDatabase(), type, start_row, segment_size); data.AppendSegment(l, std::move(new_segment)); } @@ -320423,7 +322988,6 @@ unique_ptr ColumnData::Checkpoint(RowGroup &row_group, // replace the old tree with the new one data.Replace(l, checkpoint_state->new_tree); updates.reset(); - version++; return checkpoint_state; } @@ -320725,6 +323289,9 @@ unique_ptr ColumnDataCheckpointer::DetectBestCompressionMethod(idx 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]); @@ -320807,7 +323374,7 @@ void ColumnDataCheckpointer::WritePersistentSegments() { // set up the data pointer directly using the data from the persistent segment DataPointer pointer(segment->stats.statistics.Copy()); pointer.block_pointer.block_id = segment->GetBlockId(); - pointer.block_pointer.offset = segment->GetBlockOffset(); + pointer.block_pointer.offset = NumericCast(segment->GetBlockOffset()); pointer.row_start = segment->start; pointer.tuple_count = segment->count; pointer.compression_type = segment->function.get().type; @@ -321092,12 +323659,15 @@ void ColumnSegment::CommitDropSegment() { // Filter Selection //===--------------------------------------------------------------------===// template -static idx_t TemplatedFilterSelection(T *vec, T predicate, SelectionVector &sel, idx_t approved_tuple_count, - ValidityMask &mask, SelectionVector &result_sel) { +static idx_t TemplatedFilterSelection(UnifiedVectorFormat &vdata, T predicate, SelectionVector &sel, + idx_t approved_tuple_count, SelectionVector &result_sel) { + auto &mask = vdata.validity; + auto vec = UnifiedVectorFormat::GetData(vdata); idx_t result_count = 0; for (idx_t i = 0; i < approved_tuple_count; i++) { auto idx = sel.get_index(i); - if ((!HAS_NULL || mask.RowIsValid(idx)) && OP::Operation(vec[idx], predicate)) { + auto vector_idx = vdata.sel->get_index(idx); + if ((!HAS_NULL || mask.RowIsValid(vector_idx)) && OP::Operation(vec[vector_idx], predicate)) { result_sel.set_index(result_count++, idx); } } @@ -321105,68 +323675,69 @@ static idx_t TemplatedFilterSelection(T *vec, T predicate, SelectionVector &sel, } template -static void FilterSelectionSwitch(T *vec, T predicate, SelectionVector &sel, idx_t &approved_tuple_count, - ExpressionType comparison_type, ValidityMask &mask) { +static void FilterSelectionSwitch(UnifiedVectorFormat &vdata, T predicate, SelectionVector &sel, + idx_t &approved_tuple_count, ExpressionType comparison_type) { SelectionVector new_sel(approved_tuple_count); + auto &mask = vdata.validity; // the inplace loops take the result as the last parameter switch (comparison_type) { case ExpressionType::COMPARE_EQUAL: { if (mask.AllValid()) { approved_tuple_count = - TemplatedFilterSelection(vec, predicate, sel, approved_tuple_count, mask, new_sel); + TemplatedFilterSelection(vdata, predicate, sel, approved_tuple_count, new_sel); } else { approved_tuple_count = - TemplatedFilterSelection(vec, predicate, sel, approved_tuple_count, mask, new_sel); + TemplatedFilterSelection(vdata, predicate, sel, approved_tuple_count, new_sel); } break; } case ExpressionType::COMPARE_NOTEQUAL: { if (mask.AllValid()) { approved_tuple_count = - TemplatedFilterSelection(vec, predicate, sel, approved_tuple_count, mask, new_sel); + TemplatedFilterSelection(vdata, predicate, sel, approved_tuple_count, new_sel); } else { approved_tuple_count = - TemplatedFilterSelection(vec, predicate, sel, approved_tuple_count, mask, new_sel); + TemplatedFilterSelection(vdata, predicate, sel, approved_tuple_count, new_sel); } break; } case ExpressionType::COMPARE_LESSTHAN: { if (mask.AllValid()) { approved_tuple_count = - TemplatedFilterSelection(vec, predicate, sel, approved_tuple_count, mask, new_sel); + TemplatedFilterSelection(vdata, predicate, sel, approved_tuple_count, new_sel); } else { approved_tuple_count = - TemplatedFilterSelection(vec, predicate, sel, approved_tuple_count, mask, new_sel); + TemplatedFilterSelection(vdata, predicate, sel, approved_tuple_count, new_sel); } break; } case ExpressionType::COMPARE_GREATERTHAN: { if (mask.AllValid()) { - approved_tuple_count = TemplatedFilterSelection(vec, predicate, sel, - approved_tuple_count, mask, new_sel); + approved_tuple_count = + TemplatedFilterSelection(vdata, predicate, sel, approved_tuple_count, new_sel); } else { - approved_tuple_count = TemplatedFilterSelection(vec, predicate, sel, - approved_tuple_count, mask, new_sel); + approved_tuple_count = + TemplatedFilterSelection(vdata, predicate, sel, approved_tuple_count, new_sel); } break; } case ExpressionType::COMPARE_LESSTHANOREQUALTO: { if (mask.AllValid()) { - approved_tuple_count = TemplatedFilterSelection( - vec, predicate, sel, approved_tuple_count, mask, new_sel); + approved_tuple_count = TemplatedFilterSelection(vdata, predicate, sel, + approved_tuple_count, new_sel); } else { - approved_tuple_count = TemplatedFilterSelection( - vec, predicate, sel, approved_tuple_count, mask, new_sel); + approved_tuple_count = + TemplatedFilterSelection(vdata, predicate, sel, approved_tuple_count, new_sel); } break; } case ExpressionType::COMPARE_GREATERTHANOREQUALTO: { if (mask.AllValid()) { - approved_tuple_count = TemplatedFilterSelection( - vec, predicate, sel, approved_tuple_count, mask, new_sel); + approved_tuple_count = TemplatedFilterSelection(vdata, predicate, sel, + approved_tuple_count, new_sel); } else { - approved_tuple_count = TemplatedFilterSelection( - vec, predicate, sel, approved_tuple_count, mask, new_sel); + approved_tuple_count = TemplatedFilterSelection(vdata, predicate, sel, + approved_tuple_count, new_sel); } break; } @@ -321177,7 +323748,8 @@ static void FilterSelectionSwitch(T *vec, T predicate, SelectionVector &sel, idx } template -static idx_t TemplatedNullSelection(SelectionVector &sel, idx_t &approved_tuple_count, ValidityMask &mask) { +static idx_t TemplatedNullSelection(UnifiedVectorFormat &vdata, SelectionVector &sel, idx_t &approved_tuple_count) { + auto &mask = vdata.validity; if (mask.AllValid()) { // no NULL values if (IS_NULL) { @@ -321191,7 +323763,8 @@ static idx_t TemplatedNullSelection(SelectionVector &sel, idx_t &approved_tuple_ idx_t result_count = 0; for (idx_t i = 0; i < approved_tuple_count; i++) { auto idx = sel.get_index(i); - if (mask.RowIsValid(idx) != IS_NULL) { + auto vector_idx = vdata.sel->get_index(idx); + if (mask.RowIsValid(vector_idx) != IS_NULL) { result_sel.set_index(result_count++, idx); } } @@ -321201,8 +323774,8 @@ static idx_t TemplatedNullSelection(SelectionVector &sel, idx_t &approved_tuple_ } } -idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const TableFilter &filter, - idx_t &approved_tuple_count, ValidityMask &mask) { +idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &vector, UnifiedVectorFormat &vdata, + const TableFilter &filter, idx_t scan_count, idx_t &approved_tuple_count) { switch (filter.filter_type) { case TableFilterType::CONJUNCTION_OR: { // similar to the CONJUNCTION_AND, but we need to take care of the SelectionVectors (OR all of them) @@ -321213,7 +323786,7 @@ idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const SelectionVector temp_sel; temp_sel.Initialize(sel); idx_t temp_tuple_count = approved_tuple_count; - idx_t temp_count = FilterSelection(temp_sel, result, *child_filter, temp_tuple_count, mask); + idx_t temp_count = FilterSelection(temp_sel, vector, vdata, *child_filter, scan_count, temp_tuple_count); // tuples passed, move them into the actual result vector for (idx_t i = 0; i < temp_count; i++) { auto new_idx = temp_sel.get_index(i); @@ -321236,127 +323809,111 @@ idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const case TableFilterType::CONJUNCTION_AND: { auto &conjunction_and = filter.Cast(); for (auto &child_filter : conjunction_and.child_filters) { - FilterSelection(sel, result, *child_filter, approved_tuple_count, mask); + FilterSelection(sel, vector, vdata, *child_filter, scan_count, approved_tuple_count); } return approved_tuple_count; } case TableFilterType::CONSTANT_COMPARISON: { auto &constant_filter = filter.Cast(); // the inplace loops take the result as the last parameter - switch (result.GetType().InternalType()) { + switch (vector.GetType().InternalType()) { case PhysicalType::UINT8: { - auto result_flat = FlatVector::GetData(result); auto predicate = UTinyIntValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, + constant_filter.comparison_type); break; } case PhysicalType::UINT16: { - auto result_flat = FlatVector::GetData(result); auto predicate = USmallIntValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, + constant_filter.comparison_type); break; } case PhysicalType::UINT32: { - auto result_flat = FlatVector::GetData(result); auto predicate = UIntegerValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, + constant_filter.comparison_type); break; } case PhysicalType::UINT64: { - auto result_flat = FlatVector::GetData(result); auto predicate = UBigIntValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, + constant_filter.comparison_type); break; } case PhysicalType::INT8: { - auto result_flat = FlatVector::GetData(result); auto predicate = TinyIntValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, constant_filter.comparison_type); break; } case PhysicalType::INT16: { - auto result_flat = FlatVector::GetData(result); auto predicate = SmallIntValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, + constant_filter.comparison_type); break; } case PhysicalType::INT32: { - auto result_flat = FlatVector::GetData(result); auto predicate = IntegerValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, + constant_filter.comparison_type); break; } case PhysicalType::INT64: { - auto result_flat = FlatVector::GetData(result); auto predicate = BigIntValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, + constant_filter.comparison_type); break; } case PhysicalType::INT128: { - auto result_flat = FlatVector::GetData(result); auto predicate = HugeIntValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, + constant_filter.comparison_type); break; } case PhysicalType::UINT128: { - auto result_flat = FlatVector::GetData(result); auto predicate = UhugeIntValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, + constant_filter.comparison_type); break; } case PhysicalType::FLOAT: { - auto result_flat = FlatVector::GetData(result); auto predicate = FloatValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, constant_filter.comparison_type); break; } case PhysicalType::DOUBLE: { - auto result_flat = FlatVector::GetData(result); auto predicate = DoubleValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, constant_filter.comparison_type); break; } case PhysicalType::VARCHAR: { - auto result_flat = FlatVector::GetData(result); auto predicate = string_t(StringValue::Get(constant_filter.constant)); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, + constant_filter.comparison_type); break; } case PhysicalType::BOOL: { - auto result_flat = FlatVector::GetData(result); auto predicate = BooleanValue::Get(constant_filter.constant); - FilterSelectionSwitch(result_flat, predicate, sel, approved_tuple_count, - constant_filter.comparison_type, mask); + FilterSelectionSwitch(vdata, predicate, sel, approved_tuple_count, constant_filter.comparison_type); break; } default: - throw InvalidTypeException(result.GetType(), "Invalid type for filter pushed down to table comparison"); + throw InvalidTypeException(vector.GetType(), "Invalid type for filter pushed down to table comparison"); } return approved_tuple_count; } case TableFilterType::IS_NULL: - return TemplatedNullSelection(sel, approved_tuple_count, mask); + return TemplatedNullSelection(vdata, sel, approved_tuple_count); case TableFilterType::IS_NOT_NULL: - return TemplatedNullSelection(sel, approved_tuple_count, mask); + return TemplatedNullSelection(vdata, sel, approved_tuple_count); case TableFilterType::STRUCT_EXTRACT: { auto &struct_filter = filter.Cast(); // Apply the filter on the child vector - auto &child_vec = StructVector::GetEntries(result)[struct_filter.child_idx]; - auto &child_mask = FlatVector::Validity(*child_vec); - return FilterSelection(sel, *child_vec, *struct_filter.child_filter, approved_tuple_count, child_mask); + auto &child_vec = StructVector::GetEntries(vector)[struct_filter.child_idx]; + UnifiedVectorFormat child_data; + child_vec->ToUnifiedFormat(scan_count, child_data); + return FilterSelection(sel, *child_vec, child_data, *struct_filter.child_filter, scan_count, + approved_tuple_count); } default: throw InternalException("FIXME: unsupported type for filter selection"); @@ -321669,6 +324226,7 @@ void ListColumnData::FetchRow(TransactionData transaction, ColumnFetchState &sta } void ListColumnData::CommitDropColumn() { + ColumnData::CommitDropColumn(); validity.CommitDropColumn(); child_column->CommitDropColumn(); } @@ -321837,12 +324395,12 @@ class RowVersionManager { namespace duckdb { RowGroup::RowGroup(RowGroupCollection &collection, idx_t start, idx_t count) - : SegmentBase(start, count), collection(collection) { + : SegmentBase(start, count), collection(collection), allocation_size(0) { Verify(); } RowGroup::RowGroup(RowGroupCollection &collection, RowGroupPointer &&pointer) - : SegmentBase(pointer.row_start, pointer.tuple_count), collection(collection) { + : SegmentBase(pointer.row_start, pointer.tuple_count), collection(collection), allocation_size(0) { // deserialize the columns if (pointer.data_pointers.size() != collection.GetTypes().size()) { throw IOException("Row group column count is unaligned with table column count. Corrupt file?"); @@ -321995,12 +324553,17 @@ bool RowGroup::InitializeScanWithOffset(CollectionScanState &state, idx_t vector state.vector_index = vector_offset; state.max_row_group_row = this->start > state.max_row ? 0 : MinValue(this->count, state.max_row - this->start); + auto row_number = start + vector_offset * STANDARD_VECTOR_SIZE; + if (state.max_row_group_row == 0) { + // exceeded row groups to scan + return false; + } D_ASSERT(state.column_scans); for (idx_t i = 0; i < column_ids.size(); i++) { const auto &column = column_ids[i]; if (column != COLUMN_IDENTIFIER_ROW_ID) { auto &column_data = GetColumn(column); - column_data.InitializeScanWithOffset(state.column_scans[i], start + vector_offset * STANDARD_VECTOR_SIZE); + column_data.InitializeScanWithOffset(state.column_scans[i], row_number); state.column_scans[i].scan_options = &state.GetOptions(); } else { state.column_scans[i].current = nullptr; @@ -322471,16 +325034,19 @@ void RowGroup::FetchRow(TransactionData transaction, ColumnFetchState &state, co row_t row_id, DataChunk &result, idx_t result_idx) { for (idx_t col_idx = 0; col_idx < column_ids.size(); col_idx++) { auto column = column_ids[col_idx]; + auto &result_vector = result.data[col_idx]; + D_ASSERT(result_vector.GetVectorType() == VectorType::FLAT_VECTOR); + D_ASSERT(!FlatVector::IsNull(result_vector, result_idx)); if (column == COLUMN_IDENTIFIER_ROW_ID) { // row id column: fill in the row ids - D_ASSERT(result.data[col_idx].GetType().InternalType() == PhysicalType::INT64); - result.data[col_idx].SetVectorType(VectorType::FLAT_VECTOR); - auto data = FlatVector::GetData(result.data[col_idx]); + D_ASSERT(result_vector.GetType().InternalType() == PhysicalType::INT64); + result_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto data = FlatVector::GetData(result_vector); data[result_idx] = row_id; } else { // regular column: fetch data from the base column auto &col_data = GetColumn(column); - col_data.FetchRow(transaction, state, row_id, result.data[col_idx], result_idx); + col_data.FetchRow(transaction, state, row_id, result_vector, result_idx); } } } @@ -322528,7 +325094,9 @@ void RowGroup::Append(RowGroupAppendState &state, DataChunk &chunk, idx_t append D_ASSERT(chunk.ColumnCount() == GetColumnCount()); for (idx_t i = 0; i < GetColumnCount(); i++) { auto &col_data = GetColumn(i); + auto prev_allocation_size = col_data.GetAllocationSize(); col_data.Append(state.states[i], chunk.data[i], append_count); + allocation_size += col_data.GetAllocationSize() - prev_allocation_size; } state.offset_in_row_group += append_count; } @@ -322896,7 +325464,7 @@ unique_ptr RowGroupSegmentTree::LoadSegment() { RowGroupCollection::RowGroupCollection(shared_ptr info_p, BlockManager &block_manager, vector types_p, idx_t row_start_p, idx_t total_rows_p) : block_manager(block_manager), total_rows(total_rows_p), info(std::move(info_p)), types(std::move(types_p)), - row_start(row_start_p) { + row_start(row_start_p), allocation_size(0) { row_groups = make_shared(*this); } @@ -323059,6 +325627,8 @@ bool RowGroupCollection::NextParallelScan(ClientContext &context, ParallelCollec } return true; } + lock_guard l(state.lock); + scan_state.batch_index = state.batch_index; return false; } @@ -323130,11 +325700,10 @@ void RowGroupCollection::Fetch(TransactionData transaction, DataChunk &result, c // Append //===--------------------------------------------------------------------===// TableAppendState::TableAppendState() - : row_group_append_state(*this), total_append_count(0), start_row_group(nullptr), transaction(0, 0), remaining(0) { + : row_group_append_state(*this), total_append_count(0), start_row_group(nullptr), transaction(0, 0) { } TableAppendState::~TableAppendState() { - D_ASSERT(Exception::UncaughtException() || remaining == 0); } bool RowGroupCollection::IsEmpty() const { @@ -323146,7 +325715,7 @@ bool RowGroupCollection::IsEmpty(SegmentLock &l) const { return row_groups->IsEmpty(l); } -void RowGroupCollection::InitializeAppend(TransactionData transaction, TableAppendState &state, idx_t append_count) { +void RowGroupCollection::InitializeAppend(TransactionData transaction, TableAppendState &state) { state.row_start = total_rows; state.current_row = state.row_start; state.total_append_count = 0; @@ -323160,17 +325729,12 @@ void RowGroupCollection::InitializeAppend(TransactionData transaction, TableAppe state.start_row_group = row_groups->GetLastSegment(l); D_ASSERT(this->row_start + total_rows == state.start_row_group->start + state.start_row_group->count); state.start_row_group->InitializeAppend(state.row_group_append_state); - state.remaining = append_count; state.transaction = transaction; - if (state.remaining > 0) { - state.start_row_group->AppendVersionInfo(transaction, state.remaining); - total_rows += state.remaining; - } } void RowGroupCollection::InitializeAppend(TableAppendState &state) { TransactionData tdata(0, 0); - InitializeAppend(tdata, state, 0); + InitializeAppend(tdata, state); } bool RowGroupCollection::Append(DataChunk &chunk, TableAppendState &state) { @@ -323178,16 +325742,18 @@ bool RowGroupCollection::Append(DataChunk &chunk, TableAppendState &state) { chunk.Verify(); bool new_row_group = false; - idx_t append_count = chunk.size(); + idx_t total_append_count = chunk.size(); idx_t remaining = chunk.size(); - state.total_append_count += append_count; + state.total_append_count += total_append_count; while (true) { auto current_row_group = state.row_group_append_state.row_group; // check how much we can fit into the current row_group idx_t append_count = MinValue(remaining, Storage::ROW_GROUP_SIZE - state.row_group_append_state.offset_in_row_group); if (append_count > 0) { + auto previous_allocation_size = current_row_group->GetAllocationSize(); current_row_group->Append(state.row_group_append_state, chunk, append_count); + allocation_size += current_row_group->GetAllocationSize() - previous_allocation_size; // merge the stats auto stats_lock = stats.GetLock(); for (idx_t i = 0; i < types.size(); i++) { @@ -323195,9 +325761,6 @@ bool RowGroupCollection::Append(DataChunk &chunk, TableAppendState &state) { } } remaining -= append_count; - if (state.remaining > 0) { - state.remaining -= append_count; - } if (remaining > 0) { // we expect max 1 iteration of this loop (i.e. a single chunk should never overflow more than one // row_group) @@ -323215,15 +325778,12 @@ bool RowGroupCollection::Append(DataChunk &chunk, TableAppendState &state) { // set up the append state for this row_group auto last_row_group = row_groups->GetLastSegment(l); last_row_group->InitializeAppend(state.row_group_append_state); - if (state.remaining > 0) { - last_row_group->AppendVersionInfo(state.transaction, state.remaining); - } continue; } else { break; } } - state.current_row += append_count; + state.current_row += row_t(total_append_count); auto stats_lock = stats.GetLock(); for (idx_t col_idx = 0; col_idx < types.size(); col_idx++) { stats.GetStats(col_idx).UpdateDistinctStatistics(chunk.data[col_idx], chunk.size()); @@ -323269,14 +325829,20 @@ void RowGroupCollection::CommitAppend(transaction_t commit_id, idx_t row_start, } void RowGroupCollection::RevertAppendInternal(idx_t start_row) { - if (total_rows <= start_row) { - return; - } total_rows = start_row; auto l = row_groups->Lock(); - // find the segment index that the current row belongs to - idx_t segment_index = row_groups->GetSegmentIndex(l, start_row); + idx_t segment_count = row_groups->GetSegmentCount(l); + if (segment_count == 0) { + // we have no segments to revert + return; + } + idx_t segment_index; + // find the segment index that the start row belongs to + if (!row_groups->TryGetSegmentIndex(l, start_row, segment_index)) { + // revert from the last segment + segment_index = segment_count - 1; + } auto &segment = *row_groups->GetSegmentByIndex(l, segment_index); // remove any segments AFTER this segment: they should be deleted entirely @@ -323618,11 +326184,14 @@ class VacuumTask : public BaseCheckpointTask { scan_state.Initialize(column_ids); scan_state.table_state.Initialize(types); scan_state.table_state.max_row = idx_t(-1); - idx_t next_idx = segment_idx + merge_count; - for (idx_t c_idx = segment_idx; c_idx < next_idx; c_idx++) { + idx_t merged_groups = 0; + idx_t total_row_groups = vacuum_state.row_group_counts.size(); + for (idx_t c_idx = segment_idx; merged_groups < merge_count && c_idx < total_row_groups; c_idx++) { if (vacuum_state.row_group_counts[c_idx] == 0) { continue; } + merged_groups++; + auto ¤t_row_group = *checkpoint_state.segments[c_idx].node; current_row_group.InitializeScan(scan_state.table_state); @@ -323762,7 +326331,7 @@ bool RowGroupCollection::ScheduleVacuumTasks(CollectionCheckpointState &checkpoi merge_rows, state.row_start); checkpoint_state.ScheduleTask(std::move(vacuum_task)); // skip vacuuming by the row groups we have merged - state.next_vacuum_idx = segment_idx + merge_count; + state.next_vacuum_idx = next_idx; state.row_start += merge_rows; return true; } @@ -325714,12 +328283,12 @@ void UpdateSegment::InitializeUpdateInfo(UpdateInfo &info, row_t *ids, const Sel info.next = nullptr; // set up the tuple ids - info.N = count; + info.N = UnsafeNumericCast(count); for (idx_t i = 0; i < count; i++) { auto idx = sel.get_index(i); auto id = ids[idx]; D_ASSERT(idx_t(id) >= vector_offset && idx_t(id) < vector_offset + STANDARD_VECTOR_SIZE); - info.tuples[i] = id - vector_offset; + info.tuples[i] = NumericCast(id - vector_offset); }; } @@ -325944,7 +328513,7 @@ static void MergeUpdateLoopInternal(UpdateInfo *base_info, V *base_table_data, U result_values[result_offset] = UpdateSelectElement::Operation( base_info->segment, OP::template Extract(base_table_data, update_id)); } - result_ids[result_offset++] = update_id; + result_ids[result_offset++] = UnsafeNumericCast(update_id); } // write any remaining entries from the old updates while (update_info_offset < update_info->N) { @@ -325953,7 +328522,7 @@ static void MergeUpdateLoopInternal(UpdateInfo *base_info, V *base_table_data, U update_info_offset++; } // now copy them back - update_info->N = result_offset; + update_info->N = UnsafeNumericCast(result_offset); memcpy(update_info_data, result_values, result_offset * sizeof(T)); memcpy(update_info->tuples, result_ids, result_offset * sizeof(sel_t)); @@ -325961,12 +328530,12 @@ static void MergeUpdateLoopInternal(UpdateInfo *base_info, V *base_table_data, U result_offset = 0; auto pick_new = [&](idx_t id, idx_t aidx, idx_t count) { result_values[result_offset] = OP::template Extract(update_vector_data, aidx); - result_ids[result_offset] = id; + result_ids[result_offset] = UnsafeNumericCast(id); result_offset++; }; auto pick_old = [&](idx_t id, idx_t bidx, idx_t count) { result_values[result_offset] = base_info_data[bidx]; - result_ids[result_offset] = id; + result_ids[result_offset] = UnsafeNumericCast(id); result_offset++; }; // now we perform a merge of the new ids with the old ids @@ -325975,7 +328544,7 @@ static void MergeUpdateLoopInternal(UpdateInfo *base_info, V *base_table_data, U }; MergeLoop(ids, base_info->tuples, count, base_info->N, base_id, merge, pick_new, pick_old, sel); - base_info->N = result_offset; + base_info->N = UnsafeNumericCast(result_offset); memcpy(base_info_data, result_values, result_offset * sizeof(T)); memcpy(base_info->tuples, result_ids, result_offset * sizeof(sel_t)); } @@ -326551,6 +329120,340 @@ vector TableIndexList::GetStorageInfos() { +namespace duckdb { + +//===--------------------------------------------------------------------===// +// BlockIndexManager +//===--------------------------------------------------------------------===// + +BlockIndexManager::BlockIndexManager() : max_index(0) { +} + +idx_t BlockIndexManager::GetNewBlockIndex() { + auto index = GetNewBlockIndexInternal(); + indexes_in_use.insert(index); + return index; +} + +bool BlockIndexManager::RemoveIndex(idx_t index) { + // remove this block from the set of blocks + auto entry = indexes_in_use.find(index); + if (entry == indexes_in_use.end()) { + throw InternalException("RemoveIndex - index %llu not found in indexes_in_use", index); + } + indexes_in_use.erase(entry); + free_indexes.insert(index); + // check if we can truncate the file + + // get the max_index in use right now + auto max_index_in_use = indexes_in_use.empty() ? 0 : *indexes_in_use.rbegin(); + if (max_index_in_use < max_index) { + // max index in use is lower than the max_index + // reduce the max_index + max_index = indexes_in_use.empty() ? 0 : max_index_in_use + 1; + // we can remove any free_indexes that are larger than the current max_index + while (!free_indexes.empty()) { + auto max_entry = *free_indexes.rbegin(); + if (max_entry < max_index) { + break; + } + free_indexes.erase(max_entry); + } + return true; + } + return false; +} + +idx_t BlockIndexManager::GetMaxIndex() { + return max_index; +} + +bool BlockIndexManager::HasFreeBlocks() { + return !free_indexes.empty(); +} + +idx_t BlockIndexManager::GetNewBlockIndexInternal() { + if (free_indexes.empty()) { + return max_index++; + } + auto entry = free_indexes.begin(); + auto index = *entry; + free_indexes.erase(entry); + return index; +} + +//===--------------------------------------------------------------------===// +// TemporaryFileHandle +//===--------------------------------------------------------------------===// + +TemporaryFileHandle::TemporaryFileHandle(idx_t temp_file_count, DatabaseInstance &db, const string &temp_directory, + idx_t index) + : max_allowed_index((1 << temp_file_count) * MAX_ALLOWED_INDEX_BASE), db(db), file_index(index), + path(FileSystem::GetFileSystem(db).JoinPath(temp_directory, "duckdb_temp_storage-" + to_string(index) + ".tmp")) { +} + +TemporaryFileHandle::TemporaryFileLock::TemporaryFileLock(mutex &mutex) : lock(mutex) { +} + +TemporaryFileIndex TemporaryFileHandle::TryGetBlockIndex() { + TemporaryFileLock lock(file_lock); + if (index_manager.GetMaxIndex() >= max_allowed_index && index_manager.HasFreeBlocks()) { + // file is at capacity + return TemporaryFileIndex(); + } + // open the file handle if it does not yet exist + CreateFileIfNotExists(lock); + // fetch a new block index to write to + auto block_index = index_manager.GetNewBlockIndex(); + return TemporaryFileIndex(file_index, block_index); +} + +void TemporaryFileHandle::WriteTemporaryFile(FileBuffer &buffer, TemporaryFileIndex index) { + D_ASSERT(buffer.size == Storage::BLOCK_SIZE); + buffer.Write(*handle, GetPositionInFile(index.block_index)); +} + +unique_ptr TemporaryFileHandle::ReadTemporaryBuffer(idx_t block_index, + unique_ptr reusable_buffer) { + return StandardBufferManager::ReadTemporaryBufferInternal(BufferManager::GetBufferManager(db), *handle, + GetPositionInFile(block_index), Storage::BLOCK_SIZE, + std::move(reusable_buffer)); +} + +void TemporaryFileHandle::EraseBlockIndex(block_id_t block_index) { + // remove the block (and potentially truncate the temp file) + TemporaryFileLock lock(file_lock); + D_ASSERT(handle); + RemoveTempBlockIndex(lock, block_index); +} + +bool TemporaryFileHandle::DeleteIfEmpty() { + TemporaryFileLock lock(file_lock); + if (index_manager.GetMaxIndex() > 0) { + // there are still blocks in this file + return false; + } + // the file is empty: delete it + handle.reset(); + auto &fs = FileSystem::GetFileSystem(db); + fs.RemoveFile(path); + return true; +} + +TemporaryFileInformation TemporaryFileHandle::GetTemporaryFile() { + TemporaryFileLock lock(file_lock); + TemporaryFileInformation info; + info.path = path; + info.size = GetPositionInFile(index_manager.GetMaxIndex()); + return info; +} + +void TemporaryFileHandle::CreateFileIfNotExists(TemporaryFileLock &) { + if (handle) { + return; + } + auto &fs = FileSystem::GetFileSystem(db); + uint8_t open_flags = FileFlags::FILE_FLAGS_READ | FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE; + handle = fs.OpenFile(path, open_flags); +} + +void TemporaryFileHandle::RemoveTempBlockIndex(TemporaryFileLock &, idx_t index) { + // remove the block index from the index manager + if (index_manager.RemoveIndex(index)) { + // the max_index that is currently in use has decreased + // as a result we can truncate the file +#ifndef WIN32 // this ended up causing issues when sorting + auto max_index = index_manager.GetMaxIndex(); + auto &fs = FileSystem::GetFileSystem(db); + fs.Truncate(*handle, GetPositionInFile(max_index + 1)); +#endif + } +} + +idx_t TemporaryFileHandle::GetPositionInFile(idx_t index) { + return index * Storage::BLOCK_ALLOC_SIZE; +} + +//===--------------------------------------------------------------------===// +// TemporaryDirectoryHandle +//===--------------------------------------------------------------------===// + +TemporaryDirectoryHandle::TemporaryDirectoryHandle(DatabaseInstance &db, string path_p) + : db(db), temp_directory(std::move(path_p)), temp_file(make_uniq(db, temp_directory)) { + auto &fs = FileSystem::GetFileSystem(db); + if (!temp_directory.empty()) { + if (!fs.DirectoryExists(temp_directory)) { + fs.CreateDirectory(temp_directory); + created_directory = true; + } + } +} + +TemporaryDirectoryHandle::~TemporaryDirectoryHandle() { + // first release any temporary files + temp_file.reset(); + // then delete the temporary file directory + auto &fs = FileSystem::GetFileSystem(db); + if (!temp_directory.empty()) { + bool delete_directory = created_directory; + vector files_to_delete; + if (!created_directory) { + bool deleted_everything = true; + fs.ListFiles(temp_directory, [&](const string &path, bool isdir) { + if (isdir) { + deleted_everything = false; + return; + } + if (!StringUtil::StartsWith(path, "duckdb_temp_")) { + deleted_everything = false; + return; + } + files_to_delete.push_back(path); + }); + } + if (delete_directory) { + // we want to remove all files in the directory + fs.RemoveDirectory(temp_directory); + } else { + for (auto &file : files_to_delete) { + fs.RemoveFile(fs.JoinPath(temp_directory, file)); + } + } + } +} + +TemporaryFileManager &TemporaryDirectoryHandle::GetTempFile() { + return *temp_file; +} + +//===--------------------------------------------------------------------===// +// TemporaryFileIndex +//===--------------------------------------------------------------------===// + +TemporaryFileIndex::TemporaryFileIndex(idx_t file_index, idx_t block_index) + : file_index(file_index), block_index(block_index) { +} + +bool TemporaryFileIndex::IsValid() const { + return block_index != DConstants::INVALID_INDEX; +} + +//===--------------------------------------------------------------------===// +// TemporaryFileManager +//===--------------------------------------------------------------------===// + +TemporaryFileManager::TemporaryFileManager(DatabaseInstance &db, const string &temp_directory_p) + : db(db), temp_directory(temp_directory_p) { +} + +TemporaryFileManager::TemporaryManagerLock::TemporaryManagerLock(mutex &mutex) : lock(mutex) { +} + +void TemporaryFileManager::WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer) { + D_ASSERT(buffer.size == Storage::BLOCK_SIZE); + TemporaryFileIndex index; + TemporaryFileHandle *handle = nullptr; + + { + TemporaryManagerLock lock(manager_lock); + // first check if we can write to an open existing file + for (auto &entry : files) { + auto &temp_file = entry.second; + index = temp_file->TryGetBlockIndex(); + if (index.IsValid()) { + handle = entry.second.get(); + break; + } + } + if (!handle) { + // no existing handle to write to; we need to create & open a new file + auto new_file_index = index_manager.GetNewBlockIndex(); + auto new_file = make_uniq(files.size(), db, temp_directory, new_file_index); + handle = new_file.get(); + files[new_file_index] = std::move(new_file); + + index = handle->TryGetBlockIndex(); + } + D_ASSERT(used_blocks.find(block_id) == used_blocks.end()); + used_blocks[block_id] = index; + } + D_ASSERT(handle); + D_ASSERT(index.IsValid()); + handle->WriteTemporaryFile(buffer, index); +} + +bool TemporaryFileManager::HasTemporaryBuffer(block_id_t block_id) { + lock_guard lock(manager_lock); + return used_blocks.find(block_id) != used_blocks.end(); +} + +unique_ptr TemporaryFileManager::ReadTemporaryBuffer(block_id_t id, + unique_ptr reusable_buffer) { + TemporaryFileIndex index; + TemporaryFileHandle *handle; + { + TemporaryManagerLock lock(manager_lock); + index = GetTempBlockIndex(lock, id); + handle = GetFileHandle(lock, index.file_index); + } + auto buffer = handle->ReadTemporaryBuffer(index.block_index, std::move(reusable_buffer)); + { + // remove the block (and potentially erase the temp file) + TemporaryManagerLock lock(manager_lock); + EraseUsedBlock(lock, id, handle, index); + } + return buffer; +} + +void TemporaryFileManager::DeleteTemporaryBuffer(block_id_t id) { + TemporaryManagerLock lock(manager_lock); + auto index = GetTempBlockIndex(lock, id); + auto handle = GetFileHandle(lock, index.file_index); + EraseUsedBlock(lock, id, handle, index); +} + +vector TemporaryFileManager::GetTemporaryFiles() { + lock_guard lock(manager_lock); + vector result; + for (auto &file : files) { + result.push_back(file.second->GetTemporaryFile()); + } + return result; +} + +void TemporaryFileManager::EraseUsedBlock(TemporaryManagerLock &lock, block_id_t id, TemporaryFileHandle *handle, + TemporaryFileIndex index) { + auto entry = used_blocks.find(id); + if (entry == used_blocks.end()) { + throw InternalException("EraseUsedBlock - Block %llu not found in used blocks", id); + } + used_blocks.erase(entry); + handle->EraseBlockIndex(index.block_index); + if (handle->DeleteIfEmpty()) { + EraseFileHandle(lock, index.file_index); + } +} + +// FIXME: returning a raw pointer??? +TemporaryFileHandle *TemporaryFileManager::GetFileHandle(TemporaryManagerLock &, idx_t index) { + return files[index].get(); +} + +TemporaryFileIndex TemporaryFileManager::GetTempBlockIndex(TemporaryManagerLock &, block_id_t id) { + D_ASSERT(used_blocks.find(id) != used_blocks.end()); + return used_blocks[id]; +} + +void TemporaryFileManager::EraseFileHandle(TemporaryManagerLock &, idx_t file_index) { + files.erase(file_index); + index_manager.RemoveIndex(file_index); +} + +} // namespace duckdb + + + + namespace duckdb { @@ -327434,8 +330337,9 @@ const uint64_t WAL_VERSION_NUMBER = 2; WriteAheadLog::WriteAheadLog(AttachedDatabase &database, const string &path) : skip_writing(false), database(database) { wal_path = path; writer = make_uniq(FileSystem::Get(database), path.c_str(), - FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE | - FileFlags::FILE_FLAGS_APPEND); + NumericCast(FileFlags::FILE_FLAGS_WRITE | + FileFlags::FILE_FLAGS_FILE_CREATE | + FileFlags::FILE_FLAGS_APPEND)); } WriteAheadLog::~WriteAheadLog() { @@ -328133,7 +331037,7 @@ void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) { (void)column_name; break; default: - throw InternalException("Don't know how to drop this type!"); + throw InternalException("Don't know how to alter this type!"); } auto &alter_info = parse_info->Cast(); @@ -328167,7 +331071,7 @@ void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) { log->WriteCreateTableMacro(parent.Cast()); break; default: - throw InternalException("Don't know how to drop this type!"); + throw InternalException("Don't know how to create this type!"); } } break; @@ -328335,6 +331239,8 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) { if (!StringUtil::CIEquals(catalog_entry->name, catalog_entry->Parent().name)) { catalog_entry->set->UpdateTimestamp(*catalog_entry, commit_id); } + // modify catalog on commit + duck_catalog.ModifyCatalog(); if (HAS_LOG) { // push the catalog update to the WAL @@ -328690,7 +331596,7 @@ void DuckTransactionManager::Checkpoint(ClientContext &context, bool force) { throw TransactionException("Cannot CHECKPOINT: the current transaction has transaction local changes"); } if (!force) { - if (!CanCheckpoint(current)) { + if (!CanCheckpoint(current).can_checkpoint) { throw TransactionException("Cannot CHECKPOINT: there are other transactions. Use FORCE CHECKPOINT to abort " "the other transactions and force a checkpoint"); } @@ -328705,7 +331611,7 @@ void DuckTransactionManager::Checkpoint(ClientContext &context, bool force) { connection_manager.LockClients(client_locks, context); lock.lock(); - if (!CanCheckpoint(current)) { + if (!CanCheckpoint(current).can_checkpoint) { for (size_t i = 0; i < active_transactions.size(); i++) { auto &transaction = active_transactions[i]; // rollback the transaction @@ -328723,29 +331629,41 @@ void DuckTransactionManager::Checkpoint(ClientContext &context, bool force) { } i--; } - D_ASSERT(CanCheckpoint(nullptr)); + D_ASSERT(CanCheckpoint(nullptr).can_checkpoint); } } storage_manager.CreateCheckpoint(); } -bool DuckTransactionManager::CanCheckpoint(optional_ptr current) { +DuckTransactionManager::CheckpointDecision +DuckTransactionManager::CanCheckpoint(optional_ptr current) { if (db.IsSystem()) { - return false; + return {false, "system transaction"}; } auto &storage_manager = db.GetStorageManager(); if (storage_manager.InMemory()) { - return false; + return {false, "in memory db"}; } - if (!recently_committed_transactions.empty() || !old_transactions.empty()) { - return false; + auto trans_to_string = [](const unique_ptr &t) { + return std::to_string(t->transaction_id); + }; + if (!recently_committed_transactions.empty()) { + return {false, "recently committed transactions: [" + + StringUtil::Join(recently_committed_transactions, recently_committed_transactions.size(), + ",", trans_to_string) + + "]"}; + } + if (!old_transactions.empty()) { + return {false, "old transactions: [" + + StringUtil::Join(old_transactions, old_transactions.size(), ",", trans_to_string) + "]"}; } + for (auto &transaction : active_transactions) { if (transaction.get() != current.get()) { - return false; + return {false, "current transaction [" + std::to_string(current->transaction_id) + "] isn't active"}; } } - return true; + return {true, ""}; } ErrorData DuckTransactionManager::CommitTransaction(ClientContext &context, Transaction &transaction_p) { @@ -328754,25 +331672,28 @@ ErrorData DuckTransactionManager::CommitTransaction(ClientContext &context, Tran auto lock = make_uniq>(transaction_lock); CheckpointLock checkpoint_lock(*this); // check if we can checkpoint - bool checkpoint = thread_is_checkpointing ? false : CanCheckpoint(&transaction); - if (checkpoint) { + auto checkpoint_decision = thread_is_checkpointing ? CheckpointDecision {false, "another thread is checkpointing"} + : CanCheckpoint(&transaction); + if (checkpoint_decision.can_checkpoint) { if (transaction.AutomaticCheckpoint(db)) { checkpoint_lock.Lock(); } else { - checkpoint = false; + checkpoint_decision = {false, "no reason to automatically checkpoint"}; } } + OnCommitCheckpointDecision(checkpoint_decision, transaction); + // obtain a commit id for the transaction transaction_t commit_id = current_start_timestamp++; // commit the UndoBuffer of the transaction - auto error = transaction.Commit(db, commit_id, checkpoint); + auto error = transaction.Commit(db, commit_id, checkpoint_decision.can_checkpoint); if (error.HasError()) { // commit unsuccessful: rollback the transaction instead - checkpoint = false; + checkpoint_decision = CheckpointDecision {false, error.Message()}; transaction.commit_id = 0; transaction.Rollback(); } - if (!checkpoint) { + if (!checkpoint_decision.can_checkpoint) { // we won't checkpoint after all: unlock the clients again checkpoint_lock.Unlock(); client_locks.clear(); @@ -328783,7 +331704,7 @@ ErrorData DuckTransactionManager::CommitTransaction(ClientContext &context, Tran RemoveTransaction(transaction); // now perform a checkpoint if (1) we are able to checkpoint, and (2) the WAL has reached sufficient size to // checkpoint - if (checkpoint) { + if (checkpoint_decision.can_checkpoint) { // checkpoint the database to disk auto &storage_manager = db.GetStorageManager(); storage_manager.CreateCheckpoint(false, true); @@ -328923,13 +331844,28 @@ Transaction &Transaction::Get(ClientContext &context, AttachedDatabase &db) { return meta_transaction.GetTransaction(db); } +#ifdef DEBUG +static void VerifyAllTransactionsUnique(AttachedDatabase &db, vector> &all_transactions) { + for (auto &tx : all_transactions) { + if (RefersToSameObject(db, tx.get())) { + throw InternalException("Database is already present in all_transactions"); + } + } +} +#endif + Transaction &MetaTransaction::GetTransaction(AttachedDatabase &db) { + lock_guard guard(lock); auto entry = transactions.find(db); if (entry == transactions.end()) { auto &new_transaction = db.GetTransactionManager().StartTransaction(context); new_transaction.active_query = active_query; +#ifdef DEBUG + VerifyAllTransactionsUnique(db, all_transactions); +#endif all_transactions.push_back(db); transactions.insert(make_pair(reference(db), reference(new_transaction))); + return new_transaction; } else { D_ASSERT(entry->second.get().active_query == active_query); @@ -328959,6 +331895,9 @@ Transaction &Transaction::Get(ClientContext &context, Catalog &catalog) { ErrorData MetaTransaction::Commit() { ErrorData error; +#ifdef DEBUG + reference_set_t committed_tx; +#endif // commit transactions in reverse order for (idx_t i = all_transactions.size(); i > 0; i--) { auto &db = all_transactions[i - 1].get(); @@ -328966,6 +331905,12 @@ ErrorData MetaTransaction::Commit() { if (entry == transactions.end()) { throw InternalException("Could not find transaction corresponding to database in MetaTransaction"); } +#ifdef DEBUG + auto already_committed = committed_tx.insert(db).second == false; + if (already_committed) { + throw InternalException("All databases inside all_transactions should be unique, invariant broken!"); + } +#endif auto &transaction_manager = db.GetTransactionManager(); auto &transaction = entry->second.get(); if (!error.HasError()) { @@ -329156,15 +332101,6 @@ void TransactionContext::BeginTransaction() { for (auto const &s : context.registered_state) { s.second->TransactionBegin(*current_transaction, context); } - - auto &config = DBConfig::GetConfig(context); - if (config.options.immediate_transaction_mode) { - // if immediate transaction mode is enabled then start all transactions immediately - auto databases = DatabaseManager::Get(context).GetDatabases(context); - for (auto db : databases) { - current_transaction->GetTransaction(db.get()); - } - } } void TransactionContext::Commit() { @@ -329270,7 +332206,7 @@ data_ptr_t UndoBuffer::CreateEntry(UndoFlags type, idx_t len) { auto data = allocator.Allocate(needed_space); Store(type, data); data += sizeof(UndoFlags); - Store(len, data); + Store(UnsafeNumericCast(len), data); data += sizeof(uint32_t); return data; } @@ -385394,17 +388330,17 @@ PGValue *makeString(const char *str) { // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #15 // See the end of this file for a list -/* A Bison parser, made by GNU Bison 3.8.2. */ +/* A Bison parser, made by GNU Bison 2.3. */ -/* Bison implementation for Yacc-like parsers in C +/* Skeleton implementation for Bison's Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, - Inc. + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. - This program is free software: you can redistribute it and/or modify + This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. + the Free Software Foundation; either version 2, or (at your option) + any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -385412,7 +388348,9 @@ PGValue *makeString(const char *str) { GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program. If not, see . */ + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work @@ -385430,10 +388368,6 @@ PGValue *makeString(const char *str) { /* C LALR(1) parser skeleton written by Richard Stallman, by simplifying the original so-called "semantic" parser. */ -/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, - especially those whose name start with YY_ or yy_. They are - private implementation details that can be changed or removed. */ - /* All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local variables, as they might otherwise be expanded by user macros. @@ -385441,11 +388375,11 @@ PGValue *makeString(const char *str) { define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ -/* Identify Bison output, and Bison version. */ -#define YYBISON 30802 +/* Identify Bison output. */ +#define YYBISON 1 -/* Bison version string. */ -#define YYBISON_VERSION "3.8.2" +/* Bison version. */ +#define YYBISON_VERSION "2.3" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -385453,21 +388387,1033 @@ PGValue *makeString(const char *str) { /* Pure parsers. */ #define YYPURE 1 -/* Push parsers. */ -#define YYPUSH 0 - -/* Pull parsers. */ -#define YYPULL 1 - +/* Using locations. */ +#define YYLSP_NEEDED 1 /* Substitute the variable and function names. */ -#define yyparse base_yyparse -#define yylex base_yylex -#define yyerror base_yyerror -#define yydebug base_yydebug -#define yynerrs base_yynerrs - -/* First part of user prologue. */ +#define yyparse base_yyparse +#define yylex base_yylex +#define yyerror base_yyerror +#define yylval base_yylval +#define yychar base_yychar +#define yydebug base_yydebug +#define yynerrs base_yynerrs +#define yylloc base_yylloc + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + IDENT = 258, + FCONST = 259, + SCONST = 260, + BCONST = 261, + XCONST = 262, + Op = 263, + ICONST = 264, + PARAM = 265, + TYPECAST = 266, + DOT_DOT = 267, + COLON_EQUALS = 268, + EQUALS_GREATER = 269, + INTEGER_DIVISION = 270, + POWER_OF = 271, + LAMBDA_ARROW = 272, + DOUBLE_ARROW = 273, + LESS_EQUALS = 274, + GREATER_EQUALS = 275, + NOT_EQUALS = 276, + ABORT_P = 277, + ABSOLUTE_P = 278, + ACCESS = 279, + ACTION = 280, + ADD_P = 281, + ADMIN = 282, + AFTER = 283, + AGGREGATE = 284, + ALL = 285, + ALSO = 286, + ALTER = 287, + ALWAYS = 288, + ANALYSE = 289, + ANALYZE = 290, + AND = 291, + ANTI = 292, + ANY = 293, + ARRAY = 294, + AS = 295, + ASC_P = 296, + ASOF = 297, + ASSERTION = 298, + ASSIGNMENT = 299, + ASYMMETRIC = 300, + AT = 301, + ATTACH = 302, + ATTRIBUTE = 303, + AUTHORIZATION = 304, + BACKWARD = 305, + BEFORE = 306, + BEGIN_P = 307, + BETWEEN = 308, + BIGINT = 309, + BINARY = 310, + BIT = 311, + BOOLEAN_P = 312, + BOTH = 313, + BY = 314, + CACHE = 315, + CALL_P = 316, + CALLED = 317, + CASCADE = 318, + CASCADED = 319, + CASE = 320, + CAST = 321, + CATALOG_P = 322, + CENTURIES_P = 323, + CENTURY_P = 324, + CHAIN = 325, + CHAR_P = 326, + CHARACTER = 327, + CHARACTERISTICS = 328, + CHECK_P = 329, + CHECKPOINT = 330, + CLASS = 331, + CLOSE = 332, + CLUSTER = 333, + COALESCE = 334, + COLLATE = 335, + COLLATION = 336, + COLUMN = 337, + COLUMNS = 338, + COMMENT = 339, + COMMENTS = 340, + COMMIT = 341, + COMMITTED = 342, + COMPRESSION = 343, + CONCURRENTLY = 344, + CONFIGURATION = 345, + CONFLICT = 346, + CONNECTION = 347, + CONSTRAINT = 348, + CONSTRAINTS = 349, + CONTENT_P = 350, + CONTINUE_P = 351, + CONVERSION_P = 352, + COPY = 353, + COST = 354, + CREATE_P = 355, + CROSS = 356, + CSV = 357, + CUBE = 358, + CURRENT_P = 359, + CURSOR = 360, + CYCLE = 361, + DATA_P = 362, + DATABASE = 363, + DAY_P = 364, + DAYS_P = 365, + DEALLOCATE = 366, + DEC = 367, + DECADE_P = 368, + DECADES_P = 369, + DECIMAL_P = 370, + DECLARE = 371, + DEFAULT = 372, + DEFAULTS = 373, + DEFERRABLE = 374, + DEFERRED = 375, + DEFINER = 376, + DELETE_P = 377, + DELIMITER = 378, + DELIMITERS = 379, + DEPENDS = 380, + DESC_P = 381, + DESCRIBE = 382, + DETACH = 383, + DICTIONARY = 384, + DISABLE_P = 385, + DISCARD = 386, + DISTINCT = 387, + DO = 388, + DOCUMENT_P = 389, + DOMAIN_P = 390, + DOUBLE_P = 391, + DROP = 392, + EACH = 393, + ELSE = 394, + ENABLE_P = 395, + ENCODING = 396, + ENCRYPTED = 397, + END_P = 398, + ENUM_P = 399, + ESCAPE = 400, + EVENT = 401, + EXCEPT = 402, + EXCLUDE = 403, + EXCLUDING = 404, + EXCLUSIVE = 405, + EXECUTE = 406, + EXISTS = 407, + EXPLAIN = 408, + EXPORT_P = 409, + EXPORT_STATE = 410, + EXTENSION = 411, + EXTERNAL = 412, + EXTRACT = 413, + FALSE_P = 414, + FAMILY = 415, + FETCH = 416, + FILTER = 417, + FIRST_P = 418, + FLOAT_P = 419, + FOLLOWING = 420, + FOR = 421, + FORCE = 422, + FOREIGN = 423, + FORWARD = 424, + FREEZE = 425, + FROM = 426, + FULL = 427, + FUNCTION = 428, + FUNCTIONS = 429, + GENERATED = 430, + GLOB = 431, + GLOBAL = 432, + GRANT = 433, + GRANTED = 434, + GROUP_P = 435, + GROUPING = 436, + GROUPING_ID = 437, + GROUPS = 438, + HANDLER = 439, + HAVING = 440, + HEADER_P = 441, + HOLD = 442, + HOUR_P = 443, + HOURS_P = 444, + IDENTITY_P = 445, + IF_P = 446, + IGNORE_P = 447, + ILIKE = 448, + IMMEDIATE = 449, + IMMUTABLE = 450, + IMPLICIT_P = 451, + IMPORT_P = 452, + IN_P = 453, + INCLUDE_P = 454, + INCLUDING = 455, + INCREMENT = 456, + INDEX = 457, + INDEXES = 458, + INHERIT = 459, + INHERITS = 460, + INITIALLY = 461, + INLINE_P = 462, + INNER_P = 463, + INOUT = 464, + INPUT_P = 465, + INSENSITIVE = 466, + INSERT = 467, + INSTALL = 468, + INSTEAD = 469, + INT_P = 470, + INTEGER = 471, + INTERSECT = 472, + INTERVAL = 473, + INTO = 474, + INVOKER = 475, + IS = 476, + ISNULL = 477, + ISOLATION = 478, + JOIN = 479, + JSON = 480, + KEY = 481, + LABEL = 482, + LANGUAGE = 483, + LARGE_P = 484, + LAST_P = 485, + LATERAL_P = 486, + LEADING = 487, + LEAKPROOF = 488, + LEFT = 489, + LEVEL = 490, + LIKE = 491, + LIMIT = 492, + LISTEN = 493, + LOAD = 494, + LOCAL = 495, + LOCATION = 496, + LOCK_P = 497, + LOCKED = 498, + LOGGED = 499, + MACRO = 500, + MAP = 501, + MAPPING = 502, + MATCH = 503, + MATERIALIZED = 504, + MAXVALUE = 505, + METHOD = 506, + MICROSECOND_P = 507, + MICROSECONDS_P = 508, + MILLENNIA_P = 509, + MILLENNIUM_P = 510, + MILLISECOND_P = 511, + MILLISECONDS_P = 512, + MINUTE_P = 513, + MINUTES_P = 514, + MINVALUE = 515, + MODE = 516, + MONTH_P = 517, + MONTHS_P = 518, + MOVE = 519, + NAME_P = 520, + NAMES = 521, + NATIONAL = 522, + NATURAL = 523, + NCHAR = 524, + NEW = 525, + NEXT = 526, + NO = 527, + NONE = 528, + NOT = 529, + NOTHING = 530, + NOTIFY = 531, + NOTNULL = 532, + NOWAIT = 533, + NULL_P = 534, + NULLIF = 535, + NULLS_P = 536, + NUMERIC = 537, + OBJECT_P = 538, + OF = 539, + OFF = 540, + OFFSET = 541, + OIDS = 542, + OLD = 543, + ON = 544, + ONLY = 545, + OPERATOR = 546, + OPTION = 547, + OPTIONS = 548, + OR = 549, + ORDER = 550, + ORDINALITY = 551, + OTHERS = 552, + OUT_P = 553, + OUTER_P = 554, + OVER = 555, + OVERLAPS = 556, + OVERLAY = 557, + OVERRIDING = 558, + OWNED = 559, + OWNER = 560, + PARALLEL = 561, + PARSER = 562, + PARTIAL = 563, + PARTITION = 564, + PASSING = 565, + PASSWORD = 566, + PERCENT = 567, + PERSISTENT = 568, + PIVOT = 569, + PIVOT_LONGER = 570, + PIVOT_WIDER = 571, + PLACING = 572, + PLANS = 573, + POLICY = 574, + POSITION = 575, + POSITIONAL = 576, + PRAGMA_P = 577, + PRECEDING = 578, + PRECISION = 579, + PREPARE = 580, + PREPARED = 581, + PRESERVE = 582, + PRIMARY = 583, + PRIOR = 584, + PRIVILEGES = 585, + PROCEDURAL = 586, + PROCEDURE = 587, + PROGRAM = 588, + PUBLICATION = 589, + QUALIFY = 590, + QUOTE = 591, + RANGE = 592, + READ_P = 593, + REAL = 594, + REASSIGN = 595, + RECHECK = 596, + RECURSIVE = 597, + REF = 598, + REFERENCES = 599, + REFERENCING = 600, + REFRESH = 601, + REINDEX = 602, + RELATIVE_P = 603, + RELEASE = 604, + RENAME = 605, + REPEATABLE = 606, + REPLACE = 607, + REPLICA = 608, + RESET = 609, + RESPECT_P = 610, + RESTART = 611, + RESTRICT = 612, + RETURNING = 613, + RETURNS = 614, + REVOKE = 615, + RIGHT = 616, + ROLE = 617, + ROLLBACK = 618, + ROLLUP = 619, + ROW = 620, + ROWS = 621, + RULE = 622, + SAMPLE = 623, + SAVEPOINT = 624, + SCHEMA = 625, + SCHEMAS = 626, + SCOPE = 627, + SCROLL = 628, + SEARCH = 629, + SECOND_P = 630, + SECONDS_P = 631, + SECRET = 632, + SECURITY = 633, + SELECT = 634, + SEMI = 635, + SEQUENCE = 636, + SEQUENCES = 637, + SERIALIZABLE = 638, + SERVER = 639, + SESSION = 640, + SET = 641, + SETOF = 642, + SETS = 643, + SHARE = 644, + SHOW = 645, + SIMILAR = 646, + SIMPLE = 647, + SKIP = 648, + SMALLINT = 649, + SNAPSHOT = 650, + SOME = 651, + SQL_P = 652, + STABLE = 653, + STANDALONE_P = 654, + START = 655, + STATEMENT = 656, + STATISTICS = 657, + STDIN = 658, + STDOUT = 659, + STORAGE = 660, + STORED = 661, + STRICT_P = 662, + STRIP_P = 663, + STRUCT = 664, + SUBSCRIPTION = 665, + SUBSTRING = 666, + SUMMARIZE = 667, + SYMMETRIC = 668, + SYSID = 669, + SYSTEM_P = 670, + TABLE = 671, + TABLES = 672, + TABLESAMPLE = 673, + TABLESPACE = 674, + TEMP = 675, + TEMPLATE = 676, + TEMPORARY = 677, + TEXT_P = 678, + THEN = 679, + TIES = 680, + TIME = 681, + TIMESTAMP = 682, + TO = 683, + TRAILING = 684, + TRANSACTION = 685, + TRANSFORM = 686, + TREAT = 687, + TRIGGER = 688, + TRIM = 689, + TRUE_P = 690, + TRUNCATE = 691, + TRUSTED = 692, + TRY_CAST = 693, + TYPE_P = 694, + TYPES_P = 695, + UNBOUNDED = 696, + UNCOMMITTED = 697, + UNENCRYPTED = 698, + UNION = 699, + UNIQUE = 700, + UNKNOWN = 701, + UNLISTEN = 702, + UNLOGGED = 703, + UNPIVOT = 704, + UNTIL = 705, + UPDATE = 706, + USE_P = 707, + USER = 708, + USING = 709, + VACUUM = 710, + VALID = 711, + VALIDATE = 712, + VALIDATOR = 713, + VALUE_P = 714, + VALUES = 715, + VARCHAR = 716, + VARIADIC = 717, + VARYING = 718, + VERBOSE = 719, + VERSION_P = 720, + VIEW = 721, + VIEWS = 722, + VIRTUAL = 723, + VOLATILE = 724, + WEEK_P = 725, + WEEKS_P = 726, + WHEN = 727, + WHERE = 728, + WHITESPACE_P = 729, + WINDOW = 730, + WITH = 731, + WITHIN = 732, + WITHOUT = 733, + WORK = 734, + WRAPPER = 735, + WRITE_P = 736, + XML_P = 737, + XMLATTRIBUTES = 738, + XMLCONCAT = 739, + XMLELEMENT = 740, + XMLEXISTS = 741, + XMLFOREST = 742, + XMLNAMESPACES = 743, + XMLPARSE = 744, + XMLPI = 745, + XMLROOT = 746, + XMLSERIALIZE = 747, + XMLTABLE = 748, + YEAR_P = 749, + YEARS_P = 750, + YES_P = 751, + ZONE = 752, + NOT_LA = 753, + NULLS_LA = 754, + WITH_LA = 755, + POSTFIXOP = 756, + UMINUS = 757 + }; +#endif +/* Tokens. */ +#define IDENT 258 +#define FCONST 259 +#define SCONST 260 +#define BCONST 261 +#define XCONST 262 +#define Op 263 +#define ICONST 264 +#define PARAM 265 +#define TYPECAST 266 +#define DOT_DOT 267 +#define COLON_EQUALS 268 +#define EQUALS_GREATER 269 +#define INTEGER_DIVISION 270 +#define POWER_OF 271 +#define LAMBDA_ARROW 272 +#define DOUBLE_ARROW 273 +#define LESS_EQUALS 274 +#define GREATER_EQUALS 275 +#define NOT_EQUALS 276 +#define ABORT_P 277 +#define ABSOLUTE_P 278 +#define ACCESS 279 +#define ACTION 280 +#define ADD_P 281 +#define ADMIN 282 +#define AFTER 283 +#define AGGREGATE 284 +#define ALL 285 +#define ALSO 286 +#define ALTER 287 +#define ALWAYS 288 +#define ANALYSE 289 +#define ANALYZE 290 +#define AND 291 +#define ANTI 292 +#define ANY 293 +#define ARRAY 294 +#define AS 295 +#define ASC_P 296 +#define ASOF 297 +#define ASSERTION 298 +#define ASSIGNMENT 299 +#define ASYMMETRIC 300 +#define AT 301 +#define ATTACH 302 +#define ATTRIBUTE 303 +#define AUTHORIZATION 304 +#define BACKWARD 305 +#define BEFORE 306 +#define BEGIN_P 307 +#define BETWEEN 308 +#define BIGINT 309 +#define BINARY 310 +#define BIT 311 +#define BOOLEAN_P 312 +#define BOTH 313 +#define BY 314 +#define CACHE 315 +#define CALL_P 316 +#define CALLED 317 +#define CASCADE 318 +#define CASCADED 319 +#define CASE 320 +#define CAST 321 +#define CATALOG_P 322 +#define CENTURIES_P 323 +#define CENTURY_P 324 +#define CHAIN 325 +#define CHAR_P 326 +#define CHARACTER 327 +#define CHARACTERISTICS 328 +#define CHECK_P 329 +#define CHECKPOINT 330 +#define CLASS 331 +#define CLOSE 332 +#define CLUSTER 333 +#define COALESCE 334 +#define COLLATE 335 +#define COLLATION 336 +#define COLUMN 337 +#define COLUMNS 338 +#define COMMENT 339 +#define COMMENTS 340 +#define COMMIT 341 +#define COMMITTED 342 +#define COMPRESSION 343 +#define CONCURRENTLY 344 +#define CONFIGURATION 345 +#define CONFLICT 346 +#define CONNECTION 347 +#define CONSTRAINT 348 +#define CONSTRAINTS 349 +#define CONTENT_P 350 +#define CONTINUE_P 351 +#define CONVERSION_P 352 +#define COPY 353 +#define COST 354 +#define CREATE_P 355 +#define CROSS 356 +#define CSV 357 +#define CUBE 358 +#define CURRENT_P 359 +#define CURSOR 360 +#define CYCLE 361 +#define DATA_P 362 +#define DATABASE 363 +#define DAY_P 364 +#define DAYS_P 365 +#define DEALLOCATE 366 +#define DEC 367 +#define DECADE_P 368 +#define DECADES_P 369 +#define DECIMAL_P 370 +#define DECLARE 371 +#define DEFAULT 372 +#define DEFAULTS 373 +#define DEFERRABLE 374 +#define DEFERRED 375 +#define DEFINER 376 +#define DELETE_P 377 +#define DELIMITER 378 +#define DELIMITERS 379 +#define DEPENDS 380 +#define DESC_P 381 +#define DESCRIBE 382 +#define DETACH 383 +#define DICTIONARY 384 +#define DISABLE_P 385 +#define DISCARD 386 +#define DISTINCT 387 +#define DO 388 +#define DOCUMENT_P 389 +#define DOMAIN_P 390 +#define DOUBLE_P 391 +#define DROP 392 +#define EACH 393 +#define ELSE 394 +#define ENABLE_P 395 +#define ENCODING 396 +#define ENCRYPTED 397 +#define END_P 398 +#define ENUM_P 399 +#define ESCAPE 400 +#define EVENT 401 +#define EXCEPT 402 +#define EXCLUDE 403 +#define EXCLUDING 404 +#define EXCLUSIVE 405 +#define EXECUTE 406 +#define EXISTS 407 +#define EXPLAIN 408 +#define EXPORT_P 409 +#define EXPORT_STATE 410 +#define EXTENSION 411 +#define EXTERNAL 412 +#define EXTRACT 413 +#define FALSE_P 414 +#define FAMILY 415 +#define FETCH 416 +#define FILTER 417 +#define FIRST_P 418 +#define FLOAT_P 419 +#define FOLLOWING 420 +#define FOR 421 +#define FORCE 422 +#define FOREIGN 423 +#define FORWARD 424 +#define FREEZE 425 +#define FROM 426 +#define FULL 427 +#define FUNCTION 428 +#define FUNCTIONS 429 +#define GENERATED 430 +#define GLOB 431 +#define GLOBAL 432 +#define GRANT 433 +#define GRANTED 434 +#define GROUP_P 435 +#define GROUPING 436 +#define GROUPING_ID 437 +#define GROUPS 438 +#define HANDLER 439 +#define HAVING 440 +#define HEADER_P 441 +#define HOLD 442 +#define HOUR_P 443 +#define HOURS_P 444 +#define IDENTITY_P 445 +#define IF_P 446 +#define IGNORE_P 447 +#define ILIKE 448 +#define IMMEDIATE 449 +#define IMMUTABLE 450 +#define IMPLICIT_P 451 +#define IMPORT_P 452 +#define IN_P 453 +#define INCLUDE_P 454 +#define INCLUDING 455 +#define INCREMENT 456 +#define INDEX 457 +#define INDEXES 458 +#define INHERIT 459 +#define INHERITS 460 +#define INITIALLY 461 +#define INLINE_P 462 +#define INNER_P 463 +#define INOUT 464 +#define INPUT_P 465 +#define INSENSITIVE 466 +#define INSERT 467 +#define INSTALL 468 +#define INSTEAD 469 +#define INT_P 470 +#define INTEGER 471 +#define INTERSECT 472 +#define INTERVAL 473 +#define INTO 474 +#define INVOKER 475 +#define IS 476 +#define ISNULL 477 +#define ISOLATION 478 +#define JOIN 479 +#define JSON 480 +#define KEY 481 +#define LABEL 482 +#define LANGUAGE 483 +#define LARGE_P 484 +#define LAST_P 485 +#define LATERAL_P 486 +#define LEADING 487 +#define LEAKPROOF 488 +#define LEFT 489 +#define LEVEL 490 +#define LIKE 491 +#define LIMIT 492 +#define LISTEN 493 +#define LOAD 494 +#define LOCAL 495 +#define LOCATION 496 +#define LOCK_P 497 +#define LOCKED 498 +#define LOGGED 499 +#define MACRO 500 +#define MAP 501 +#define MAPPING 502 +#define MATCH 503 +#define MATERIALIZED 504 +#define MAXVALUE 505 +#define METHOD 506 +#define MICROSECOND_P 507 +#define MICROSECONDS_P 508 +#define MILLENNIA_P 509 +#define MILLENNIUM_P 510 +#define MILLISECOND_P 511 +#define MILLISECONDS_P 512 +#define MINUTE_P 513 +#define MINUTES_P 514 +#define MINVALUE 515 +#define MODE 516 +#define MONTH_P 517 +#define MONTHS_P 518 +#define MOVE 519 +#define NAME_P 520 +#define NAMES 521 +#define NATIONAL 522 +#define NATURAL 523 +#define NCHAR 524 +#define NEW 525 +#define NEXT 526 +#define NO 527 +#define NONE 528 +#define NOT 529 +#define NOTHING 530 +#define NOTIFY 531 +#define NOTNULL 532 +#define NOWAIT 533 +#define NULL_P 534 +#define NULLIF 535 +#define NULLS_P 536 +#define NUMERIC 537 +#define OBJECT_P 538 +#define OF 539 +#define OFF 540 +#define OFFSET 541 +#define OIDS 542 +#define OLD 543 +#define ON 544 +#define ONLY 545 +#define OPERATOR 546 +#define OPTION 547 +#define OPTIONS 548 +#define OR 549 +#define ORDER 550 +#define ORDINALITY 551 +#define OTHERS 552 +#define OUT_P 553 +#define OUTER_P 554 +#define OVER 555 +#define OVERLAPS 556 +#define OVERLAY 557 +#define OVERRIDING 558 +#define OWNED 559 +#define OWNER 560 +#define PARALLEL 561 +#define PARSER 562 +#define PARTIAL 563 +#define PARTITION 564 +#define PASSING 565 +#define PASSWORD 566 +#define PERCENT 567 +#define PERSISTENT 568 +#define PIVOT 569 +#define PIVOT_LONGER 570 +#define PIVOT_WIDER 571 +#define PLACING 572 +#define PLANS 573 +#define POLICY 574 +#define POSITION 575 +#define POSITIONAL 576 +#define PRAGMA_P 577 +#define PRECEDING 578 +#define PRECISION 579 +#define PREPARE 580 +#define PREPARED 581 +#define PRESERVE 582 +#define PRIMARY 583 +#define PRIOR 584 +#define PRIVILEGES 585 +#define PROCEDURAL 586 +#define PROCEDURE 587 +#define PROGRAM 588 +#define PUBLICATION 589 +#define QUALIFY 590 +#define QUOTE 591 +#define RANGE 592 +#define READ_P 593 +#define REAL 594 +#define REASSIGN 595 +#define RECHECK 596 +#define RECURSIVE 597 +#define REF 598 +#define REFERENCES 599 +#define REFERENCING 600 +#define REFRESH 601 +#define REINDEX 602 +#define RELATIVE_P 603 +#define RELEASE 604 +#define RENAME 605 +#define REPEATABLE 606 +#define REPLACE 607 +#define REPLICA 608 +#define RESET 609 +#define RESPECT_P 610 +#define RESTART 611 +#define RESTRICT 612 +#define RETURNING 613 +#define RETURNS 614 +#define REVOKE 615 +#define RIGHT 616 +#define ROLE 617 +#define ROLLBACK 618 +#define ROLLUP 619 +#define ROW 620 +#define ROWS 621 +#define RULE 622 +#define SAMPLE 623 +#define SAVEPOINT 624 +#define SCHEMA 625 +#define SCHEMAS 626 +#define SCOPE 627 +#define SCROLL 628 +#define SEARCH 629 +#define SECOND_P 630 +#define SECONDS_P 631 +#define SECRET 632 +#define SECURITY 633 +#define SELECT 634 +#define SEMI 635 +#define SEQUENCE 636 +#define SEQUENCES 637 +#define SERIALIZABLE 638 +#define SERVER 639 +#define SESSION 640 +#define SET 641 +#define SETOF 642 +#define SETS 643 +#define SHARE 644 +#define SHOW 645 +#define SIMILAR 646 +#define SIMPLE 647 +#define SKIP 648 +#define SMALLINT 649 +#define SNAPSHOT 650 +#define SOME 651 +#define SQL_P 652 +#define STABLE 653 +#define STANDALONE_P 654 +#define START 655 +#define STATEMENT 656 +#define STATISTICS 657 +#define STDIN 658 +#define STDOUT 659 +#define STORAGE 660 +#define STORED 661 +#define STRICT_P 662 +#define STRIP_P 663 +#define STRUCT 664 +#define SUBSCRIPTION 665 +#define SUBSTRING 666 +#define SUMMARIZE 667 +#define SYMMETRIC 668 +#define SYSID 669 +#define SYSTEM_P 670 +#define TABLE 671 +#define TABLES 672 +#define TABLESAMPLE 673 +#define TABLESPACE 674 +#define TEMP 675 +#define TEMPLATE 676 +#define TEMPORARY 677 +#define TEXT_P 678 +#define THEN 679 +#define TIES 680 +#define TIME 681 +#define TIMESTAMP 682 +#define TO 683 +#define TRAILING 684 +#define TRANSACTION 685 +#define TRANSFORM 686 +#define TREAT 687 +#define TRIGGER 688 +#define TRIM 689 +#define TRUE_P 690 +#define TRUNCATE 691 +#define TRUSTED 692 +#define TRY_CAST 693 +#define TYPE_P 694 +#define TYPES_P 695 +#define UNBOUNDED 696 +#define UNCOMMITTED 697 +#define UNENCRYPTED 698 +#define UNION 699 +#define UNIQUE 700 +#define UNKNOWN 701 +#define UNLISTEN 702 +#define UNLOGGED 703 +#define UNPIVOT 704 +#define UNTIL 705 +#define UPDATE 706 +#define USE_P 707 +#define USER 708 +#define USING 709 +#define VACUUM 710 +#define VALID 711 +#define VALIDATE 712 +#define VALIDATOR 713 +#define VALUE_P 714 +#define VALUES 715 +#define VARCHAR 716 +#define VARIADIC 717 +#define VARYING 718 +#define VERBOSE 719 +#define VERSION_P 720 +#define VIEW 721 +#define VIEWS 722 +#define VIRTUAL 723 +#define VOLATILE 724 +#define WEEK_P 725 +#define WEEKS_P 726 +#define WHEN 727 +#define WHERE 728 +#define WHITESPACE_P 729 +#define WINDOW 730 +#define WITH 731 +#define WITHIN 732 +#define WITHOUT 733 +#define WORK 734 +#define WRAPPER 735 +#define WRITE_P 736 +#define XML_P 737 +#define XMLATTRIBUTES 738 +#define XMLCONCAT 739 +#define XMLELEMENT 740 +#define XMLEXISTS 741 +#define XMLFOREST 742 +#define XMLNAMESPACES 743 +#define XMLPARSE 744 +#define XMLPI 745 +#define XMLROOT 746 +#define XMLSERIALIZE 747 +#define XMLTABLE 748 +#define YEAR_P 749 +#define YEARS_P 750 +#define YES_P 751 +#define ZONE 752 +#define NOT_LA 753 +#define NULLS_LA 754 +#define WITH_LA 755 +#define POSTFIXOP 756 +#define UMINUS 757 + + + + +/* Copy the first part of user declarations. */ #line 1 "third_party/libpg_query/grammar/grammar.y.tmp" #line 1 "third_party/libpg_query/grammar/grammar.hpp" @@ -385693,17 +389639,17 @@ namespace duckdb_libpgquery { // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #15 // See the end of this file for a list -/* A Bison parser, made by GNU Bison 3.8.2. */ +/* A Bison parser, made by GNU Bison 2.3. */ -/* Bison interface for Yacc-like parsers in C +/* Skeleton interface for Bison's Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, - Inc. + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. - This program is free software: you can redistribute it and/or modify + This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. + the Free Software Foundation; either version 2, or (at your option) + any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -385711,7 +389657,9 @@ namespace duckdb_libpgquery { GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program. If not, see . */ + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work @@ -385726,539 +389674,1023 @@ namespace duckdb_libpgquery { This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ -/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, - especially those whose name start with YY_ or yy_. They are - private implementation details that can be changed or removed. */ - -#ifndef YY_BASE_YY_THIRD_PARTY_LIBPG_QUERY_GRAMMAR_GRAMMAR_OUT_HPP_INCLUDED -# define YY_BASE_YY_THIRD_PARTY_LIBPG_QUERY_GRAMMAR_GRAMMAR_OUT_HPP_INCLUDED -/* Debug traces. */ -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif -#if YYDEBUG -extern int base_yydebug; -#endif - -/* Token kinds. */ +/* Tokens. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE - enum yytokentype - { - YYEMPTY = -2, - YYEOF = 0, /* "end of file" */ - YYerror = 256, /* error */ - YYUNDEF = 257, /* "invalid token" */ - IDENT = 258, /* IDENT */ - FCONST = 259, /* FCONST */ - SCONST = 260, /* SCONST */ - BCONST = 261, /* BCONST */ - XCONST = 262, /* XCONST */ - Op = 263, /* Op */ - ICONST = 264, /* ICONST */ - PARAM = 265, /* PARAM */ - TYPECAST = 266, /* TYPECAST */ - DOT_DOT = 267, /* DOT_DOT */ - COLON_EQUALS = 268, /* COLON_EQUALS */ - EQUALS_GREATER = 269, /* EQUALS_GREATER */ - INTEGER_DIVISION = 270, /* INTEGER_DIVISION */ - POWER_OF = 271, /* POWER_OF */ - LAMBDA_ARROW = 272, /* LAMBDA_ARROW */ - DOUBLE_ARROW = 273, /* DOUBLE_ARROW */ - LESS_EQUALS = 274, /* LESS_EQUALS */ - GREATER_EQUALS = 275, /* GREATER_EQUALS */ - NOT_EQUALS = 276, /* NOT_EQUALS */ - ABORT_P = 277, /* ABORT_P */ - ABSOLUTE_P = 278, /* ABSOLUTE_P */ - ACCESS = 279, /* ACCESS */ - ACTION = 280, /* ACTION */ - ADD_P = 281, /* ADD_P */ - ADMIN = 282, /* ADMIN */ - AFTER = 283, /* AFTER */ - AGGREGATE = 284, /* AGGREGATE */ - ALL = 285, /* ALL */ - ALSO = 286, /* ALSO */ - ALTER = 287, /* ALTER */ - ALWAYS = 288, /* ALWAYS */ - ANALYSE = 289, /* ANALYSE */ - ANALYZE = 290, /* ANALYZE */ - AND = 291, /* AND */ - ANTI = 292, /* ANTI */ - ANY = 293, /* ANY */ - ARRAY = 294, /* ARRAY */ - AS = 295, /* AS */ - ASC_P = 296, /* ASC_P */ - ASOF = 297, /* ASOF */ - ASSERTION = 298, /* ASSERTION */ - ASSIGNMENT = 299, /* ASSIGNMENT */ - ASYMMETRIC = 300, /* ASYMMETRIC */ - AT = 301, /* AT */ - ATTACH = 302, /* ATTACH */ - ATTRIBUTE = 303, /* ATTRIBUTE */ - AUTHORIZATION = 304, /* AUTHORIZATION */ - BACKWARD = 305, /* BACKWARD */ - BEFORE = 306, /* BEFORE */ - BEGIN_P = 307, /* BEGIN_P */ - BETWEEN = 308, /* BETWEEN */ - BIGINT = 309, /* BIGINT */ - BINARY = 310, /* BINARY */ - BIT = 311, /* BIT */ - BOOLEAN_P = 312, /* BOOLEAN_P */ - BOTH = 313, /* BOTH */ - BY = 314, /* BY */ - CACHE = 315, /* CACHE */ - CALL_P = 316, /* CALL_P */ - CALLED = 317, /* CALLED */ - CASCADE = 318, /* CASCADE */ - CASCADED = 319, /* CASCADED */ - CASE = 320, /* CASE */ - CAST = 321, /* CAST */ - CATALOG_P = 322, /* CATALOG_P */ - CENTURIES_P = 323, /* CENTURIES_P */ - CENTURY_P = 324, /* CENTURY_P */ - CHAIN = 325, /* CHAIN */ - CHAR_P = 326, /* CHAR_P */ - CHARACTER = 327, /* CHARACTER */ - CHARACTERISTICS = 328, /* CHARACTERISTICS */ - CHECK_P = 329, /* CHECK_P */ - CHECKPOINT = 330, /* CHECKPOINT */ - CLASS = 331, /* CLASS */ - CLOSE = 332, /* CLOSE */ - CLUSTER = 333, /* CLUSTER */ - COALESCE = 334, /* COALESCE */ - COLLATE = 335, /* COLLATE */ - COLLATION = 336, /* COLLATION */ - COLUMN = 337, /* COLUMN */ - COLUMNS = 338, /* COLUMNS */ - COMMENT = 339, /* COMMENT */ - COMMENTS = 340, /* COMMENTS */ - COMMIT = 341, /* COMMIT */ - COMMITTED = 342, /* COMMITTED */ - COMPRESSION = 343, /* COMPRESSION */ - CONCURRENTLY = 344, /* CONCURRENTLY */ - CONFIGURATION = 345, /* CONFIGURATION */ - CONFLICT = 346, /* CONFLICT */ - CONNECTION = 347, /* CONNECTION */ - CONSTRAINT = 348, /* CONSTRAINT */ - CONSTRAINTS = 349, /* CONSTRAINTS */ - CONTENT_P = 350, /* CONTENT_P */ - CONTINUE_P = 351, /* CONTINUE_P */ - CONVERSION_P = 352, /* CONVERSION_P */ - COPY = 353, /* COPY */ - COST = 354, /* COST */ - CREATE_P = 355, /* CREATE_P */ - CROSS = 356, /* CROSS */ - CSV = 357, /* CSV */ - CUBE = 358, /* CUBE */ - CURRENT_P = 359, /* CURRENT_P */ - CURSOR = 360, /* CURSOR */ - CYCLE = 361, /* CYCLE */ - DATA_P = 362, /* DATA_P */ - DATABASE = 363, /* DATABASE */ - DAY_P = 364, /* DAY_P */ - DAYS_P = 365, /* DAYS_P */ - DEALLOCATE = 366, /* DEALLOCATE */ - DEC = 367, /* DEC */ - DECADE_P = 368, /* DECADE_P */ - DECADES_P = 369, /* DECADES_P */ - DECIMAL_P = 370, /* DECIMAL_P */ - DECLARE = 371, /* DECLARE */ - DEFAULT = 372, /* DEFAULT */ - DEFAULTS = 373, /* DEFAULTS */ - DEFERRABLE = 374, /* DEFERRABLE */ - DEFERRED = 375, /* DEFERRED */ - DEFINER = 376, /* DEFINER */ - DELETE_P = 377, /* DELETE_P */ - DELIMITER = 378, /* DELIMITER */ - DELIMITERS = 379, /* DELIMITERS */ - DEPENDS = 380, /* DEPENDS */ - DESC_P = 381, /* DESC_P */ - DESCRIBE = 382, /* DESCRIBE */ - DETACH = 383, /* DETACH */ - DICTIONARY = 384, /* DICTIONARY */ - DISABLE_P = 385, /* DISABLE_P */ - DISCARD = 386, /* DISCARD */ - DISTINCT = 387, /* DISTINCT */ - DO = 388, /* DO */ - DOCUMENT_P = 389, /* DOCUMENT_P */ - DOMAIN_P = 390, /* DOMAIN_P */ - DOUBLE_P = 391, /* DOUBLE_P */ - DROP = 392, /* DROP */ - EACH = 393, /* EACH */ - ELSE = 394, /* ELSE */ - ENABLE_P = 395, /* ENABLE_P */ - ENCODING = 396, /* ENCODING */ - ENCRYPTED = 397, /* ENCRYPTED */ - END_P = 398, /* END_P */ - ENUM_P = 399, /* ENUM_P */ - ESCAPE = 400, /* ESCAPE */ - EVENT = 401, /* EVENT */ - EXCEPT = 402, /* EXCEPT */ - EXCLUDE = 403, /* EXCLUDE */ - EXCLUDING = 404, /* EXCLUDING */ - EXCLUSIVE = 405, /* EXCLUSIVE */ - EXECUTE = 406, /* EXECUTE */ - EXISTS = 407, /* EXISTS */ - EXPLAIN = 408, /* EXPLAIN */ - EXPORT_P = 409, /* EXPORT_P */ - EXPORT_STATE = 410, /* EXPORT_STATE */ - EXTENSION = 411, /* EXTENSION */ - EXTERNAL = 412, /* EXTERNAL */ - EXTRACT = 413, /* EXTRACT */ - FALSE_P = 414, /* FALSE_P */ - FAMILY = 415, /* FAMILY */ - FETCH = 416, /* FETCH */ - FILTER = 417, /* FILTER */ - FIRST_P = 418, /* FIRST_P */ - FLOAT_P = 419, /* FLOAT_P */ - FOLLOWING = 420, /* FOLLOWING */ - FOR = 421, /* FOR */ - FORCE = 422, /* FORCE */ - FOREIGN = 423, /* FOREIGN */ - FORWARD = 424, /* FORWARD */ - FREEZE = 425, /* FREEZE */ - FROM = 426, /* FROM */ - FULL = 427, /* FULL */ - FUNCTION = 428, /* FUNCTION */ - FUNCTIONS = 429, /* FUNCTIONS */ - GENERATED = 430, /* GENERATED */ - GLOB = 431, /* GLOB */ - GLOBAL = 432, /* GLOBAL */ - GRANT = 433, /* GRANT */ - GRANTED = 434, /* GRANTED */ - GROUP_P = 435, /* GROUP_P */ - GROUPING = 436, /* GROUPING */ - GROUPING_ID = 437, /* GROUPING_ID */ - GROUPS = 438, /* GROUPS */ - HANDLER = 439, /* HANDLER */ - HAVING = 440, /* HAVING */ - HEADER_P = 441, /* HEADER_P */ - HOLD = 442, /* HOLD */ - HOUR_P = 443, /* HOUR_P */ - HOURS_P = 444, /* HOURS_P */ - IDENTITY_P = 445, /* IDENTITY_P */ - IF_P = 446, /* IF_P */ - IGNORE_P = 447, /* IGNORE_P */ - ILIKE = 448, /* ILIKE */ - IMMEDIATE = 449, /* IMMEDIATE */ - IMMUTABLE = 450, /* IMMUTABLE */ - IMPLICIT_P = 451, /* IMPLICIT_P */ - IMPORT_P = 452, /* IMPORT_P */ - IN_P = 453, /* IN_P */ - INCLUDE_P = 454, /* INCLUDE_P */ - INCLUDING = 455, /* INCLUDING */ - INCREMENT = 456, /* INCREMENT */ - INDEX = 457, /* INDEX */ - INDEXES = 458, /* INDEXES */ - INHERIT = 459, /* INHERIT */ - INHERITS = 460, /* INHERITS */ - INITIALLY = 461, /* INITIALLY */ - INLINE_P = 462, /* INLINE_P */ - INNER_P = 463, /* INNER_P */ - INOUT = 464, /* INOUT */ - INPUT_P = 465, /* INPUT_P */ - INSENSITIVE = 466, /* INSENSITIVE */ - INSERT = 467, /* INSERT */ - INSTALL = 468, /* INSTALL */ - INSTEAD = 469, /* INSTEAD */ - INT_P = 470, /* INT_P */ - INTEGER = 471, /* INTEGER */ - INTERSECT = 472, /* INTERSECT */ - INTERVAL = 473, /* INTERVAL */ - INTO = 474, /* INTO */ - INVOKER = 475, /* INVOKER */ - IS = 476, /* IS */ - ISNULL = 477, /* ISNULL */ - ISOLATION = 478, /* ISOLATION */ - JOIN = 479, /* JOIN */ - JSON = 480, /* JSON */ - KEY = 481, /* KEY */ - LABEL = 482, /* LABEL */ - LANGUAGE = 483, /* LANGUAGE */ - LARGE_P = 484, /* LARGE_P */ - LAST_P = 485, /* LAST_P */ - LATERAL_P = 486, /* LATERAL_P */ - LEADING = 487, /* LEADING */ - LEAKPROOF = 488, /* LEAKPROOF */ - LEFT = 489, /* LEFT */ - LEVEL = 490, /* LEVEL */ - LIKE = 491, /* LIKE */ - LIMIT = 492, /* LIMIT */ - LISTEN = 493, /* LISTEN */ - LOAD = 494, /* LOAD */ - LOCAL = 495, /* LOCAL */ - LOCATION = 496, /* LOCATION */ - LOCK_P = 497, /* LOCK_P */ - LOCKED = 498, /* LOCKED */ - LOGGED = 499, /* LOGGED */ - MACRO = 500, /* MACRO */ - MAP = 501, /* MAP */ - MAPPING = 502, /* MAPPING */ - MATCH = 503, /* MATCH */ - MATERIALIZED = 504, /* MATERIALIZED */ - MAXVALUE = 505, /* MAXVALUE */ - METHOD = 506, /* METHOD */ - MICROSECOND_P = 507, /* MICROSECOND_P */ - MICROSECONDS_P = 508, /* MICROSECONDS_P */ - MILLENNIA_P = 509, /* MILLENNIA_P */ - MILLENNIUM_P = 510, /* MILLENNIUM_P */ - MILLISECOND_P = 511, /* MILLISECOND_P */ - MILLISECONDS_P = 512, /* MILLISECONDS_P */ - MINUTE_P = 513, /* MINUTE_P */ - MINUTES_P = 514, /* MINUTES_P */ - MINVALUE = 515, /* MINVALUE */ - MODE = 516, /* MODE */ - MONTH_P = 517, /* MONTH_P */ - MONTHS_P = 518, /* MONTHS_P */ - MOVE = 519, /* MOVE */ - NAME_P = 520, /* NAME_P */ - NAMES = 521, /* NAMES */ - NATIONAL = 522, /* NATIONAL */ - NATURAL = 523, /* NATURAL */ - NCHAR = 524, /* NCHAR */ - NEW = 525, /* NEW */ - NEXT = 526, /* NEXT */ - NO = 527, /* NO */ - NONE = 528, /* NONE */ - NOT = 529, /* NOT */ - NOTHING = 530, /* NOTHING */ - NOTIFY = 531, /* NOTIFY */ - NOTNULL = 532, /* NOTNULL */ - NOWAIT = 533, /* NOWAIT */ - NULL_P = 534, /* NULL_P */ - NULLIF = 535, /* NULLIF */ - NULLS_P = 536, /* NULLS_P */ - NUMERIC = 537, /* NUMERIC */ - OBJECT_P = 538, /* OBJECT_P */ - OF = 539, /* OF */ - OFF = 540, /* OFF */ - OFFSET = 541, /* OFFSET */ - OIDS = 542, /* OIDS */ - OLD = 543, /* OLD */ - ON = 544, /* ON */ - ONLY = 545, /* ONLY */ - OPERATOR = 546, /* OPERATOR */ - OPTION = 547, /* OPTION */ - OPTIONS = 548, /* OPTIONS */ - OR = 549, /* OR */ - ORDER = 550, /* ORDER */ - ORDINALITY = 551, /* ORDINALITY */ - OTHERS = 552, /* OTHERS */ - OUT_P = 553, /* OUT_P */ - OUTER_P = 554, /* OUTER_P */ - OVER = 555, /* OVER */ - OVERLAPS = 556, /* OVERLAPS */ - OVERLAY = 557, /* OVERLAY */ - OVERRIDING = 558, /* OVERRIDING */ - OWNED = 559, /* OWNED */ - OWNER = 560, /* OWNER */ - PARALLEL = 561, /* PARALLEL */ - PARSER = 562, /* PARSER */ - PARTIAL = 563, /* PARTIAL */ - PARTITION = 564, /* PARTITION */ - PASSING = 565, /* PASSING */ - PASSWORD = 566, /* PASSWORD */ - PERCENT = 567, /* PERCENT */ - PERSISTENT = 568, /* PERSISTENT */ - PIVOT = 569, /* PIVOT */ - PIVOT_LONGER = 570, /* PIVOT_LONGER */ - PIVOT_WIDER = 571, /* PIVOT_WIDER */ - PLACING = 572, /* PLACING */ - PLANS = 573, /* PLANS */ - POLICY = 574, /* POLICY */ - POSITION = 575, /* POSITION */ - POSITIONAL = 576, /* POSITIONAL */ - PRAGMA_P = 577, /* PRAGMA_P */ - PRECEDING = 578, /* PRECEDING */ - PRECISION = 579, /* PRECISION */ - PREPARE = 580, /* PREPARE */ - PREPARED = 581, /* PREPARED */ - PRESERVE = 582, /* PRESERVE */ - PRIMARY = 583, /* PRIMARY */ - PRIOR = 584, /* PRIOR */ - PRIVILEGES = 585, /* PRIVILEGES */ - PROCEDURAL = 586, /* PROCEDURAL */ - PROCEDURE = 587, /* PROCEDURE */ - PROGRAM = 588, /* PROGRAM */ - PUBLICATION = 589, /* PUBLICATION */ - QUALIFY = 590, /* QUALIFY */ - QUOTE = 591, /* QUOTE */ - RANGE = 592, /* RANGE */ - READ_P = 593, /* READ_P */ - REAL = 594, /* REAL */ - REASSIGN = 595, /* REASSIGN */ - RECHECK = 596, /* RECHECK */ - RECURSIVE = 597, /* RECURSIVE */ - REF = 598, /* REF */ - REFERENCES = 599, /* REFERENCES */ - REFERENCING = 600, /* REFERENCING */ - REFRESH = 601, /* REFRESH */ - REINDEX = 602, /* REINDEX */ - RELATIVE_P = 603, /* RELATIVE_P */ - RELEASE = 604, /* RELEASE */ - RENAME = 605, /* RENAME */ - REPEATABLE = 606, /* REPEATABLE */ - REPLACE = 607, /* REPLACE */ - REPLICA = 608, /* REPLICA */ - RESET = 609, /* RESET */ - RESPECT_P = 610, /* RESPECT_P */ - RESTART = 611, /* RESTART */ - RESTRICT = 612, /* RESTRICT */ - RETURNING = 613, /* RETURNING */ - RETURNS = 614, /* RETURNS */ - REVOKE = 615, /* REVOKE */ - RIGHT = 616, /* RIGHT */ - ROLE = 617, /* ROLE */ - ROLLBACK = 618, /* ROLLBACK */ - ROLLUP = 619, /* ROLLUP */ - ROW = 620, /* ROW */ - ROWS = 621, /* ROWS */ - RULE = 622, /* RULE */ - SAMPLE = 623, /* SAMPLE */ - SAVEPOINT = 624, /* SAVEPOINT */ - SCHEMA = 625, /* SCHEMA */ - SCHEMAS = 626, /* SCHEMAS */ - SCOPE = 627, /* SCOPE */ - SCROLL = 628, /* SCROLL */ - SEARCH = 629, /* SEARCH */ - SECOND_P = 630, /* SECOND_P */ - SECONDS_P = 631, /* SECONDS_P */ - SECRET = 632, /* SECRET */ - SECURITY = 633, /* SECURITY */ - SELECT = 634, /* SELECT */ - SEMI = 635, /* SEMI */ - SEQUENCE = 636, /* SEQUENCE */ - SEQUENCES = 637, /* SEQUENCES */ - SERIALIZABLE = 638, /* SERIALIZABLE */ - SERVER = 639, /* SERVER */ - SESSION = 640, /* SESSION */ - SET = 641, /* SET */ - SETOF = 642, /* SETOF */ - SETS = 643, /* SETS */ - SHARE = 644, /* SHARE */ - SHOW = 645, /* SHOW */ - SIMILAR = 646, /* SIMILAR */ - SIMPLE = 647, /* SIMPLE */ - SKIP = 648, /* SKIP */ - SMALLINT = 649, /* SMALLINT */ - SNAPSHOT = 650, /* SNAPSHOT */ - SOME = 651, /* SOME */ - SQL_P = 652, /* SQL_P */ - STABLE = 653, /* STABLE */ - STANDALONE_P = 654, /* STANDALONE_P */ - START = 655, /* START */ - STATEMENT = 656, /* STATEMENT */ - STATISTICS = 657, /* STATISTICS */ - STDIN = 658, /* STDIN */ - STDOUT = 659, /* STDOUT */ - STORAGE = 660, /* STORAGE */ - STORED = 661, /* STORED */ - STRICT_P = 662, /* STRICT_P */ - STRIP_P = 663, /* STRIP_P */ - STRUCT = 664, /* STRUCT */ - SUBSCRIPTION = 665, /* SUBSCRIPTION */ - SUBSTRING = 666, /* SUBSTRING */ - SUMMARIZE = 667, /* SUMMARIZE */ - SYMMETRIC = 668, /* SYMMETRIC */ - SYSID = 669, /* SYSID */ - SYSTEM_P = 670, /* SYSTEM_P */ - TABLE = 671, /* TABLE */ - TABLES = 672, /* TABLES */ - TABLESAMPLE = 673, /* TABLESAMPLE */ - TABLESPACE = 674, /* TABLESPACE */ - TEMP = 675, /* TEMP */ - TEMPLATE = 676, /* TEMPLATE */ - TEMPORARY = 677, /* TEMPORARY */ - TEXT_P = 678, /* TEXT_P */ - THEN = 679, /* THEN */ - TIES = 680, /* TIES */ - TIME = 681, /* TIME */ - TIMESTAMP = 682, /* TIMESTAMP */ - TO = 683, /* TO */ - TRAILING = 684, /* TRAILING */ - TRANSACTION = 685, /* TRANSACTION */ - TRANSFORM = 686, /* TRANSFORM */ - TREAT = 687, /* TREAT */ - TRIGGER = 688, /* TRIGGER */ - TRIM = 689, /* TRIM */ - TRUE_P = 690, /* TRUE_P */ - TRUNCATE = 691, /* TRUNCATE */ - TRUSTED = 692, /* TRUSTED */ - TRY_CAST = 693, /* TRY_CAST */ - TYPE_P = 694, /* TYPE_P */ - TYPES_P = 695, /* TYPES_P */ - UNBOUNDED = 696, /* UNBOUNDED */ - UNCOMMITTED = 697, /* UNCOMMITTED */ - UNENCRYPTED = 698, /* UNENCRYPTED */ - UNION = 699, /* UNION */ - UNIQUE = 700, /* UNIQUE */ - UNKNOWN = 701, /* UNKNOWN */ - UNLISTEN = 702, /* UNLISTEN */ - UNLOGGED = 703, /* UNLOGGED */ - UNPIVOT = 704, /* UNPIVOT */ - UNTIL = 705, /* UNTIL */ - UPDATE = 706, /* UPDATE */ - USE_P = 707, /* USE_P */ - USER = 708, /* USER */ - USING = 709, /* USING */ - VACUUM = 710, /* VACUUM */ - VALID = 711, /* VALID */ - VALIDATE = 712, /* VALIDATE */ - VALIDATOR = 713, /* VALIDATOR */ - VALUE_P = 714, /* VALUE_P */ - VALUES = 715, /* VALUES */ - VARCHAR = 716, /* VARCHAR */ - VARIADIC = 717, /* VARIADIC */ - VARYING = 718, /* VARYING */ - VERBOSE = 719, /* VERBOSE */ - VERSION_P = 720, /* VERSION_P */ - VIEW = 721, /* VIEW */ - VIEWS = 722, /* VIEWS */ - VIRTUAL = 723, /* VIRTUAL */ - VOLATILE = 724, /* VOLATILE */ - WEEK_P = 725, /* WEEK_P */ - WEEKS_P = 726, /* WEEKS_P */ - WHEN = 727, /* WHEN */ - WHERE = 728, /* WHERE */ - WHITESPACE_P = 729, /* WHITESPACE_P */ - WINDOW = 730, /* WINDOW */ - WITH = 731, /* WITH */ - WITHIN = 732, /* WITHIN */ - WITHOUT = 733, /* WITHOUT */ - WORK = 734, /* WORK */ - WRAPPER = 735, /* WRAPPER */ - WRITE_P = 736, /* WRITE_P */ - XML_P = 737, /* XML_P */ - XMLATTRIBUTES = 738, /* XMLATTRIBUTES */ - XMLCONCAT = 739, /* XMLCONCAT */ - XMLELEMENT = 740, /* XMLELEMENT */ - XMLEXISTS = 741, /* XMLEXISTS */ - XMLFOREST = 742, /* XMLFOREST */ - XMLNAMESPACES = 743, /* XMLNAMESPACES */ - XMLPARSE = 744, /* XMLPARSE */ - XMLPI = 745, /* XMLPI */ - XMLROOT = 746, /* XMLROOT */ - XMLSERIALIZE = 747, /* XMLSERIALIZE */ - XMLTABLE = 748, /* XMLTABLE */ - YEAR_P = 749, /* YEAR_P */ - YEARS_P = 750, /* YEARS_P */ - YES_P = 751, /* YES_P */ - ZONE = 752, /* ZONE */ - NOT_LA = 753, /* NOT_LA */ - NULLS_LA = 754, /* NULLS_LA */ - WITH_LA = 755, /* WITH_LA */ - POSTFIXOP = 756, /* POSTFIXOP */ - UMINUS = 757 /* UMINUS */ - }; - typedef enum yytokentype yytoken_kind_t; + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + IDENT = 258, + FCONST = 259, + SCONST = 260, + BCONST = 261, + XCONST = 262, + Op = 263, + ICONST = 264, + PARAM = 265, + TYPECAST = 266, + DOT_DOT = 267, + COLON_EQUALS = 268, + EQUALS_GREATER = 269, + INTEGER_DIVISION = 270, + POWER_OF = 271, + LAMBDA_ARROW = 272, + DOUBLE_ARROW = 273, + LESS_EQUALS = 274, + GREATER_EQUALS = 275, + NOT_EQUALS = 276, + ABORT_P = 277, + ABSOLUTE_P = 278, + ACCESS = 279, + ACTION = 280, + ADD_P = 281, + ADMIN = 282, + AFTER = 283, + AGGREGATE = 284, + ALL = 285, + ALSO = 286, + ALTER = 287, + ALWAYS = 288, + ANALYSE = 289, + ANALYZE = 290, + AND = 291, + ANTI = 292, + ANY = 293, + ARRAY = 294, + AS = 295, + ASC_P = 296, + ASOF = 297, + ASSERTION = 298, + ASSIGNMENT = 299, + ASYMMETRIC = 300, + AT = 301, + ATTACH = 302, + ATTRIBUTE = 303, + AUTHORIZATION = 304, + BACKWARD = 305, + BEFORE = 306, + BEGIN_P = 307, + BETWEEN = 308, + BIGINT = 309, + BINARY = 310, + BIT = 311, + BOOLEAN_P = 312, + BOTH = 313, + BY = 314, + CACHE = 315, + CALL_P = 316, + CALLED = 317, + CASCADE = 318, + CASCADED = 319, + CASE = 320, + CAST = 321, + CATALOG_P = 322, + CENTURIES_P = 323, + CENTURY_P = 324, + CHAIN = 325, + CHAR_P = 326, + CHARACTER = 327, + CHARACTERISTICS = 328, + CHECK_P = 329, + CHECKPOINT = 330, + CLASS = 331, + CLOSE = 332, + CLUSTER = 333, + COALESCE = 334, + COLLATE = 335, + COLLATION = 336, + COLUMN = 337, + COLUMNS = 338, + COMMENT = 339, + COMMENTS = 340, + COMMIT = 341, + COMMITTED = 342, + COMPRESSION = 343, + CONCURRENTLY = 344, + CONFIGURATION = 345, + CONFLICT = 346, + CONNECTION = 347, + CONSTRAINT = 348, + CONSTRAINTS = 349, + CONTENT_P = 350, + CONTINUE_P = 351, + CONVERSION_P = 352, + COPY = 353, + COST = 354, + CREATE_P = 355, + CROSS = 356, + CSV = 357, + CUBE = 358, + CURRENT_P = 359, + CURSOR = 360, + CYCLE = 361, + DATA_P = 362, + DATABASE = 363, + DAY_P = 364, + DAYS_P = 365, + DEALLOCATE = 366, + DEC = 367, + DECADE_P = 368, + DECADES_P = 369, + DECIMAL_P = 370, + DECLARE = 371, + DEFAULT = 372, + DEFAULTS = 373, + DEFERRABLE = 374, + DEFERRED = 375, + DEFINER = 376, + DELETE_P = 377, + DELIMITER = 378, + DELIMITERS = 379, + DEPENDS = 380, + DESC_P = 381, + DESCRIBE = 382, + DETACH = 383, + DICTIONARY = 384, + DISABLE_P = 385, + DISCARD = 386, + DISTINCT = 387, + DO = 388, + DOCUMENT_P = 389, + DOMAIN_P = 390, + DOUBLE_P = 391, + DROP = 392, + EACH = 393, + ELSE = 394, + ENABLE_P = 395, + ENCODING = 396, + ENCRYPTED = 397, + END_P = 398, + ENUM_P = 399, + ESCAPE = 400, + EVENT = 401, + EXCEPT = 402, + EXCLUDE = 403, + EXCLUDING = 404, + EXCLUSIVE = 405, + EXECUTE = 406, + EXISTS = 407, + EXPLAIN = 408, + EXPORT_P = 409, + EXPORT_STATE = 410, + EXTENSION = 411, + EXTERNAL = 412, + EXTRACT = 413, + FALSE_P = 414, + FAMILY = 415, + FETCH = 416, + FILTER = 417, + FIRST_P = 418, + FLOAT_P = 419, + FOLLOWING = 420, + FOR = 421, + FORCE = 422, + FOREIGN = 423, + FORWARD = 424, + FREEZE = 425, + FROM = 426, + FULL = 427, + FUNCTION = 428, + FUNCTIONS = 429, + GENERATED = 430, + GLOB = 431, + GLOBAL = 432, + GRANT = 433, + GRANTED = 434, + GROUP_P = 435, + GROUPING = 436, + GROUPING_ID = 437, + GROUPS = 438, + HANDLER = 439, + HAVING = 440, + HEADER_P = 441, + HOLD = 442, + HOUR_P = 443, + HOURS_P = 444, + IDENTITY_P = 445, + IF_P = 446, + IGNORE_P = 447, + ILIKE = 448, + IMMEDIATE = 449, + IMMUTABLE = 450, + IMPLICIT_P = 451, + IMPORT_P = 452, + IN_P = 453, + INCLUDE_P = 454, + INCLUDING = 455, + INCREMENT = 456, + INDEX = 457, + INDEXES = 458, + INHERIT = 459, + INHERITS = 460, + INITIALLY = 461, + INLINE_P = 462, + INNER_P = 463, + INOUT = 464, + INPUT_P = 465, + INSENSITIVE = 466, + INSERT = 467, + INSTALL = 468, + INSTEAD = 469, + INT_P = 470, + INTEGER = 471, + INTERSECT = 472, + INTERVAL = 473, + INTO = 474, + INVOKER = 475, + IS = 476, + ISNULL = 477, + ISOLATION = 478, + JOIN = 479, + JSON = 480, + KEY = 481, + LABEL = 482, + LANGUAGE = 483, + LARGE_P = 484, + LAST_P = 485, + LATERAL_P = 486, + LEADING = 487, + LEAKPROOF = 488, + LEFT = 489, + LEVEL = 490, + LIKE = 491, + LIMIT = 492, + LISTEN = 493, + LOAD = 494, + LOCAL = 495, + LOCATION = 496, + LOCK_P = 497, + LOCKED = 498, + LOGGED = 499, + MACRO = 500, + MAP = 501, + MAPPING = 502, + MATCH = 503, + MATERIALIZED = 504, + MAXVALUE = 505, + METHOD = 506, + MICROSECOND_P = 507, + MICROSECONDS_P = 508, + MILLENNIA_P = 509, + MILLENNIUM_P = 510, + MILLISECOND_P = 511, + MILLISECONDS_P = 512, + MINUTE_P = 513, + MINUTES_P = 514, + MINVALUE = 515, + MODE = 516, + MONTH_P = 517, + MONTHS_P = 518, + MOVE = 519, + NAME_P = 520, + NAMES = 521, + NATIONAL = 522, + NATURAL = 523, + NCHAR = 524, + NEW = 525, + NEXT = 526, + NO = 527, + NONE = 528, + NOT = 529, + NOTHING = 530, + NOTIFY = 531, + NOTNULL = 532, + NOWAIT = 533, + NULL_P = 534, + NULLIF = 535, + NULLS_P = 536, + NUMERIC = 537, + OBJECT_P = 538, + OF = 539, + OFF = 540, + OFFSET = 541, + OIDS = 542, + OLD = 543, + ON = 544, + ONLY = 545, + OPERATOR = 546, + OPTION = 547, + OPTIONS = 548, + OR = 549, + ORDER = 550, + ORDINALITY = 551, + OTHERS = 552, + OUT_P = 553, + OUTER_P = 554, + OVER = 555, + OVERLAPS = 556, + OVERLAY = 557, + OVERRIDING = 558, + OWNED = 559, + OWNER = 560, + PARALLEL = 561, + PARSER = 562, + PARTIAL = 563, + PARTITION = 564, + PASSING = 565, + PASSWORD = 566, + PERCENT = 567, + PERSISTENT = 568, + PIVOT = 569, + PIVOT_LONGER = 570, + PIVOT_WIDER = 571, + PLACING = 572, + PLANS = 573, + POLICY = 574, + POSITION = 575, + POSITIONAL = 576, + PRAGMA_P = 577, + PRECEDING = 578, + PRECISION = 579, + PREPARE = 580, + PREPARED = 581, + PRESERVE = 582, + PRIMARY = 583, + PRIOR = 584, + PRIVILEGES = 585, + PROCEDURAL = 586, + PROCEDURE = 587, + PROGRAM = 588, + PUBLICATION = 589, + QUALIFY = 590, + QUOTE = 591, + RANGE = 592, + READ_P = 593, + REAL = 594, + REASSIGN = 595, + RECHECK = 596, + RECURSIVE = 597, + REF = 598, + REFERENCES = 599, + REFERENCING = 600, + REFRESH = 601, + REINDEX = 602, + RELATIVE_P = 603, + RELEASE = 604, + RENAME = 605, + REPEATABLE = 606, + REPLACE = 607, + REPLICA = 608, + RESET = 609, + RESPECT_P = 610, + RESTART = 611, + RESTRICT = 612, + RETURNING = 613, + RETURNS = 614, + REVOKE = 615, + RIGHT = 616, + ROLE = 617, + ROLLBACK = 618, + ROLLUP = 619, + ROW = 620, + ROWS = 621, + RULE = 622, + SAMPLE = 623, + SAVEPOINT = 624, + SCHEMA = 625, + SCHEMAS = 626, + SCOPE = 627, + SCROLL = 628, + SEARCH = 629, + SECOND_P = 630, + SECONDS_P = 631, + SECRET = 632, + SECURITY = 633, + SELECT = 634, + SEMI = 635, + SEQUENCE = 636, + SEQUENCES = 637, + SERIALIZABLE = 638, + SERVER = 639, + SESSION = 640, + SET = 641, + SETOF = 642, + SETS = 643, + SHARE = 644, + SHOW = 645, + SIMILAR = 646, + SIMPLE = 647, + SKIP = 648, + SMALLINT = 649, + SNAPSHOT = 650, + SOME = 651, + SQL_P = 652, + STABLE = 653, + STANDALONE_P = 654, + START = 655, + STATEMENT = 656, + STATISTICS = 657, + STDIN = 658, + STDOUT = 659, + STORAGE = 660, + STORED = 661, + STRICT_P = 662, + STRIP_P = 663, + STRUCT = 664, + SUBSCRIPTION = 665, + SUBSTRING = 666, + SUMMARIZE = 667, + SYMMETRIC = 668, + SYSID = 669, + SYSTEM_P = 670, + TABLE = 671, + TABLES = 672, + TABLESAMPLE = 673, + TABLESPACE = 674, + TEMP = 675, + TEMPLATE = 676, + TEMPORARY = 677, + TEXT_P = 678, + THEN = 679, + TIES = 680, + TIME = 681, + TIMESTAMP = 682, + TO = 683, + TRAILING = 684, + TRANSACTION = 685, + TRANSFORM = 686, + TREAT = 687, + TRIGGER = 688, + TRIM = 689, + TRUE_P = 690, + TRUNCATE = 691, + TRUSTED = 692, + TRY_CAST = 693, + TYPE_P = 694, + TYPES_P = 695, + UNBOUNDED = 696, + UNCOMMITTED = 697, + UNENCRYPTED = 698, + UNION = 699, + UNIQUE = 700, + UNKNOWN = 701, + UNLISTEN = 702, + UNLOGGED = 703, + UNPIVOT = 704, + UNTIL = 705, + UPDATE = 706, + USE_P = 707, + USER = 708, + USING = 709, + VACUUM = 710, + VALID = 711, + VALIDATE = 712, + VALIDATOR = 713, + VALUE_P = 714, + VALUES = 715, + VARCHAR = 716, + VARIADIC = 717, + VARYING = 718, + VERBOSE = 719, + VERSION_P = 720, + VIEW = 721, + VIEWS = 722, + VIRTUAL = 723, + VOLATILE = 724, + WEEK_P = 725, + WEEKS_P = 726, + WHEN = 727, + WHERE = 728, + WHITESPACE_P = 729, + WINDOW = 730, + WITH = 731, + WITHIN = 732, + WITHOUT = 733, + WORK = 734, + WRAPPER = 735, + WRITE_P = 736, + XML_P = 737, + XMLATTRIBUTES = 738, + XMLCONCAT = 739, + XMLELEMENT = 740, + XMLEXISTS = 741, + XMLFOREST = 742, + XMLNAMESPACES = 743, + XMLPARSE = 744, + XMLPI = 745, + XMLROOT = 746, + XMLSERIALIZE = 747, + XMLTABLE = 748, + YEAR_P = 749, + YEARS_P = 750, + YES_P = 751, + ZONE = 752, + NOT_LA = 753, + NULLS_LA = 754, + WITH_LA = 755, + POSTFIXOP = 756, + UMINUS = 757 + }; #endif +/* Tokens. */ +#define IDENT 258 +#define FCONST 259 +#define SCONST 260 +#define BCONST 261 +#define XCONST 262 +#define Op 263 +#define ICONST 264 +#define PARAM 265 +#define TYPECAST 266 +#define DOT_DOT 267 +#define COLON_EQUALS 268 +#define EQUALS_GREATER 269 +#define INTEGER_DIVISION 270 +#define POWER_OF 271 +#define LAMBDA_ARROW 272 +#define DOUBLE_ARROW 273 +#define LESS_EQUALS 274 +#define GREATER_EQUALS 275 +#define NOT_EQUALS 276 +#define ABORT_P 277 +#define ABSOLUTE_P 278 +#define ACCESS 279 +#define ACTION 280 +#define ADD_P 281 +#define ADMIN 282 +#define AFTER 283 +#define AGGREGATE 284 +#define ALL 285 +#define ALSO 286 +#define ALTER 287 +#define ALWAYS 288 +#define ANALYSE 289 +#define ANALYZE 290 +#define AND 291 +#define ANTI 292 +#define ANY 293 +#define ARRAY 294 +#define AS 295 +#define ASC_P 296 +#define ASOF 297 +#define ASSERTION 298 +#define ASSIGNMENT 299 +#define ASYMMETRIC 300 +#define AT 301 +#define ATTACH 302 +#define ATTRIBUTE 303 +#define AUTHORIZATION 304 +#define BACKWARD 305 +#define BEFORE 306 +#define BEGIN_P 307 +#define BETWEEN 308 +#define BIGINT 309 +#define BINARY 310 +#define BIT 311 +#define BOOLEAN_P 312 +#define BOTH 313 +#define BY 314 +#define CACHE 315 +#define CALL_P 316 +#define CALLED 317 +#define CASCADE 318 +#define CASCADED 319 +#define CASE 320 +#define CAST 321 +#define CATALOG_P 322 +#define CENTURIES_P 323 +#define CENTURY_P 324 +#define CHAIN 325 +#define CHAR_P 326 +#define CHARACTER 327 +#define CHARACTERISTICS 328 +#define CHECK_P 329 +#define CHECKPOINT 330 +#define CLASS 331 +#define CLOSE 332 +#define CLUSTER 333 +#define COALESCE 334 +#define COLLATE 335 +#define COLLATION 336 +#define COLUMN 337 +#define COLUMNS 338 +#define COMMENT 339 +#define COMMENTS 340 +#define COMMIT 341 +#define COMMITTED 342 +#define COMPRESSION 343 +#define CONCURRENTLY 344 +#define CONFIGURATION 345 +#define CONFLICT 346 +#define CONNECTION 347 +#define CONSTRAINT 348 +#define CONSTRAINTS 349 +#define CONTENT_P 350 +#define CONTINUE_P 351 +#define CONVERSION_P 352 +#define COPY 353 +#define COST 354 +#define CREATE_P 355 +#define CROSS 356 +#define CSV 357 +#define CUBE 358 +#define CURRENT_P 359 +#define CURSOR 360 +#define CYCLE 361 +#define DATA_P 362 +#define DATABASE 363 +#define DAY_P 364 +#define DAYS_P 365 +#define DEALLOCATE 366 +#define DEC 367 +#define DECADE_P 368 +#define DECADES_P 369 +#define DECIMAL_P 370 +#define DECLARE 371 +#define DEFAULT 372 +#define DEFAULTS 373 +#define DEFERRABLE 374 +#define DEFERRED 375 +#define DEFINER 376 +#define DELETE_P 377 +#define DELIMITER 378 +#define DELIMITERS 379 +#define DEPENDS 380 +#define DESC_P 381 +#define DESCRIBE 382 +#define DETACH 383 +#define DICTIONARY 384 +#define DISABLE_P 385 +#define DISCARD 386 +#define DISTINCT 387 +#define DO 388 +#define DOCUMENT_P 389 +#define DOMAIN_P 390 +#define DOUBLE_P 391 +#define DROP 392 +#define EACH 393 +#define ELSE 394 +#define ENABLE_P 395 +#define ENCODING 396 +#define ENCRYPTED 397 +#define END_P 398 +#define ENUM_P 399 +#define ESCAPE 400 +#define EVENT 401 +#define EXCEPT 402 +#define EXCLUDE 403 +#define EXCLUDING 404 +#define EXCLUSIVE 405 +#define EXECUTE 406 +#define EXISTS 407 +#define EXPLAIN 408 +#define EXPORT_P 409 +#define EXPORT_STATE 410 +#define EXTENSION 411 +#define EXTERNAL 412 +#define EXTRACT 413 +#define FALSE_P 414 +#define FAMILY 415 +#define FETCH 416 +#define FILTER 417 +#define FIRST_P 418 +#define FLOAT_P 419 +#define FOLLOWING 420 +#define FOR 421 +#define FORCE 422 +#define FOREIGN 423 +#define FORWARD 424 +#define FREEZE 425 +#define FROM 426 +#define FULL 427 +#define FUNCTION 428 +#define FUNCTIONS 429 +#define GENERATED 430 +#define GLOB 431 +#define GLOBAL 432 +#define GRANT 433 +#define GRANTED 434 +#define GROUP_P 435 +#define GROUPING 436 +#define GROUPING_ID 437 +#define GROUPS 438 +#define HANDLER 439 +#define HAVING 440 +#define HEADER_P 441 +#define HOLD 442 +#define HOUR_P 443 +#define HOURS_P 444 +#define IDENTITY_P 445 +#define IF_P 446 +#define IGNORE_P 447 +#define ILIKE 448 +#define IMMEDIATE 449 +#define IMMUTABLE 450 +#define IMPLICIT_P 451 +#define IMPORT_P 452 +#define IN_P 453 +#define INCLUDE_P 454 +#define INCLUDING 455 +#define INCREMENT 456 +#define INDEX 457 +#define INDEXES 458 +#define INHERIT 459 +#define INHERITS 460 +#define INITIALLY 461 +#define INLINE_P 462 +#define INNER_P 463 +#define INOUT 464 +#define INPUT_P 465 +#define INSENSITIVE 466 +#define INSERT 467 +#define INSTALL 468 +#define INSTEAD 469 +#define INT_P 470 +#define INTEGER 471 +#define INTERSECT 472 +#define INTERVAL 473 +#define INTO 474 +#define INVOKER 475 +#define IS 476 +#define ISNULL 477 +#define ISOLATION 478 +#define JOIN 479 +#define JSON 480 +#define KEY 481 +#define LABEL 482 +#define LANGUAGE 483 +#define LARGE_P 484 +#define LAST_P 485 +#define LATERAL_P 486 +#define LEADING 487 +#define LEAKPROOF 488 +#define LEFT 489 +#define LEVEL 490 +#define LIKE 491 +#define LIMIT 492 +#define LISTEN 493 +#define LOAD 494 +#define LOCAL 495 +#define LOCATION 496 +#define LOCK_P 497 +#define LOCKED 498 +#define LOGGED 499 +#define MACRO 500 +#define MAP 501 +#define MAPPING 502 +#define MATCH 503 +#define MATERIALIZED 504 +#define MAXVALUE 505 +#define METHOD 506 +#define MICROSECOND_P 507 +#define MICROSECONDS_P 508 +#define MILLENNIA_P 509 +#define MILLENNIUM_P 510 +#define MILLISECOND_P 511 +#define MILLISECONDS_P 512 +#define MINUTE_P 513 +#define MINUTES_P 514 +#define MINVALUE 515 +#define MODE 516 +#define MONTH_P 517 +#define MONTHS_P 518 +#define MOVE 519 +#define NAME_P 520 +#define NAMES 521 +#define NATIONAL 522 +#define NATURAL 523 +#define NCHAR 524 +#define NEW 525 +#define NEXT 526 +#define NO 527 +#define NONE 528 +#define NOT 529 +#define NOTHING 530 +#define NOTIFY 531 +#define NOTNULL 532 +#define NOWAIT 533 +#define NULL_P 534 +#define NULLIF 535 +#define NULLS_P 536 +#define NUMERIC 537 +#define OBJECT_P 538 +#define OF 539 +#define OFF 540 +#define OFFSET 541 +#define OIDS 542 +#define OLD 543 +#define ON 544 +#define ONLY 545 +#define OPERATOR 546 +#define OPTION 547 +#define OPTIONS 548 +#define OR 549 +#define ORDER 550 +#define ORDINALITY 551 +#define OTHERS 552 +#define OUT_P 553 +#define OUTER_P 554 +#define OVER 555 +#define OVERLAPS 556 +#define OVERLAY 557 +#define OVERRIDING 558 +#define OWNED 559 +#define OWNER 560 +#define PARALLEL 561 +#define PARSER 562 +#define PARTIAL 563 +#define PARTITION 564 +#define PASSING 565 +#define PASSWORD 566 +#define PERCENT 567 +#define PERSISTENT 568 +#define PIVOT 569 +#define PIVOT_LONGER 570 +#define PIVOT_WIDER 571 +#define PLACING 572 +#define PLANS 573 +#define POLICY 574 +#define POSITION 575 +#define POSITIONAL 576 +#define PRAGMA_P 577 +#define PRECEDING 578 +#define PRECISION 579 +#define PREPARE 580 +#define PREPARED 581 +#define PRESERVE 582 +#define PRIMARY 583 +#define PRIOR 584 +#define PRIVILEGES 585 +#define PROCEDURAL 586 +#define PROCEDURE 587 +#define PROGRAM 588 +#define PUBLICATION 589 +#define QUALIFY 590 +#define QUOTE 591 +#define RANGE 592 +#define READ_P 593 +#define REAL 594 +#define REASSIGN 595 +#define RECHECK 596 +#define RECURSIVE 597 +#define REF 598 +#define REFERENCES 599 +#define REFERENCING 600 +#define REFRESH 601 +#define REINDEX 602 +#define RELATIVE_P 603 +#define RELEASE 604 +#define RENAME 605 +#define REPEATABLE 606 +#define REPLACE 607 +#define REPLICA 608 +#define RESET 609 +#define RESPECT_P 610 +#define RESTART 611 +#define RESTRICT 612 +#define RETURNING 613 +#define RETURNS 614 +#define REVOKE 615 +#define RIGHT 616 +#define ROLE 617 +#define ROLLBACK 618 +#define ROLLUP 619 +#define ROW 620 +#define ROWS 621 +#define RULE 622 +#define SAMPLE 623 +#define SAVEPOINT 624 +#define SCHEMA 625 +#define SCHEMAS 626 +#define SCOPE 627 +#define SCROLL 628 +#define SEARCH 629 +#define SECOND_P 630 +#define SECONDS_P 631 +#define SECRET 632 +#define SECURITY 633 +#define SELECT 634 +#define SEMI 635 +#define SEQUENCE 636 +#define SEQUENCES 637 +#define SERIALIZABLE 638 +#define SERVER 639 +#define SESSION 640 +#define SET 641 +#define SETOF 642 +#define SETS 643 +#define SHARE 644 +#define SHOW 645 +#define SIMILAR 646 +#define SIMPLE 647 +#define SKIP 648 +#define SMALLINT 649 +#define SNAPSHOT 650 +#define SOME 651 +#define SQL_P 652 +#define STABLE 653 +#define STANDALONE_P 654 +#define START 655 +#define STATEMENT 656 +#define STATISTICS 657 +#define STDIN 658 +#define STDOUT 659 +#define STORAGE 660 +#define STORED 661 +#define STRICT_P 662 +#define STRIP_P 663 +#define STRUCT 664 +#define SUBSCRIPTION 665 +#define SUBSTRING 666 +#define SUMMARIZE 667 +#define SYMMETRIC 668 +#define SYSID 669 +#define SYSTEM_P 670 +#define TABLE 671 +#define TABLES 672 +#define TABLESAMPLE 673 +#define TABLESPACE 674 +#define TEMP 675 +#define TEMPLATE 676 +#define TEMPORARY 677 +#define TEXT_P 678 +#define THEN 679 +#define TIES 680 +#define TIME 681 +#define TIMESTAMP 682 +#define TO 683 +#define TRAILING 684 +#define TRANSACTION 685 +#define TRANSFORM 686 +#define TREAT 687 +#define TRIGGER 688 +#define TRIM 689 +#define TRUE_P 690 +#define TRUNCATE 691 +#define TRUSTED 692 +#define TRY_CAST 693 +#define TYPE_P 694 +#define TYPES_P 695 +#define UNBOUNDED 696 +#define UNCOMMITTED 697 +#define UNENCRYPTED 698 +#define UNION 699 +#define UNIQUE 700 +#define UNKNOWN 701 +#define UNLISTEN 702 +#define UNLOGGED 703 +#define UNPIVOT 704 +#define UNTIL 705 +#define UPDATE 706 +#define USE_P 707 +#define USER 708 +#define USING 709 +#define VACUUM 710 +#define VALID 711 +#define VALIDATE 712 +#define VALIDATOR 713 +#define VALUE_P 714 +#define VALUES 715 +#define VARCHAR 716 +#define VARIADIC 717 +#define VARYING 718 +#define VERBOSE 719 +#define VERSION_P 720 +#define VIEW 721 +#define VIEWS 722 +#define VIRTUAL 723 +#define VOLATILE 724 +#define WEEK_P 725 +#define WEEKS_P 726 +#define WHEN 727 +#define WHERE 728 +#define WHITESPACE_P 729 +#define WINDOW 730 +#define WITH 731 +#define WITHIN 732 +#define WITHOUT 733 +#define WORK 734 +#define WRAPPER 735 +#define WRITE_P 736 +#define XML_P 737 +#define XMLATTRIBUTES 738 +#define XMLCONCAT 739 +#define XMLELEMENT 740 +#define XMLEXISTS 741 +#define XMLFOREST 742 +#define XMLNAMESPACES 743 +#define XMLPARSE 744 +#define XMLPI 745 +#define XMLROOT 746 +#define XMLSERIALIZE 747 +#define XMLTABLE 748 +#define YEAR_P 749 +#define YEARS_P 750 +#define YES_P 751 +#define ZONE 752 +#define NOT_LA 753 +#define NULLS_LA 754 +#define WITH_LA 755 +#define POSTFIXOP 756 +#define UMINUS 757 + + + -/* Value type. */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED -union YYSTYPE -{ +typedef union YYSTYPE #line 14 "third_party/libpg_query/grammar/grammar.y" - +{ core_YYSTYPE core_yystype; /* these fields must match core_YYSTYPE: */ int ival; @@ -386304,25 +390736,26 @@ union YYSTYPE PGSubLinkType subquerytype; PGViewCheckOption viewcheckoption; PGInsertColumnOrder bynameorposition; - -#line 614 "third_party/libpg_query/grammar/grammar_out.hpp" - -}; -typedef union YYSTYPE YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1 +} +/* Line 1529 of yacc.c. */ +#line 1101 "third_party/libpg_query/grammar/grammar_out.hpp" + YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 #endif -/* Location type. */ + + #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED -typedef struct YYLTYPE YYLTYPE; -struct YYLTYPE +typedef struct YYLTYPE { int first_line; int first_column; int last_line; int last_column; -}; +} YYLTYPE; +# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ # define YYLTYPE_IS_DECLARED 1 # define YYLTYPE_IS_TRIVIAL 1 #endif @@ -386330,12 +390763,6 @@ struct YYLTYPE -int base_yyparse (core_yyscan_t yyscanner); - - -#endif /* !YY_BASE_YY_THIRD_PARTY_LIBPG_QUERY_GRAMMAR_GRAMMAR_OUT_HPP_INCLUDED */ - - // LICENSE_CHANGE_END @@ -386753,1108 +391180,132 @@ static PGNode *makeRecursiveViewSelect(char *relname, PGList *aliases, PGNode *q static PGNode *makeLimitPercent(PGNode *limit_percent); -#line 241 "third_party/libpg_query/grammar/grammar_out.cpp" - -# ifndef YY_CAST -# ifdef __cplusplus -# define YY_CAST(Type, Val) static_cast (Val) -# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) -# else -# define YY_CAST(Type, Val) ((Type) (Val)) -# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) -# endif -# endif -# ifndef YY_NULLPTR -# if defined __cplusplus -# if 201103L <= __cplusplus -# define YY_NULLPTR nullptr -# else -# define YY_NULLPTR 0 -# endif -# else -# define YY_NULLPTR ((void*)0) -# endif -# endif +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif -/* Symbol kind. */ -enum yysymbol_kind_t -{ - YYSYMBOL_YYEMPTY = -2, - YYSYMBOL_YYEOF = 0, /* "end of file" */ - YYSYMBOL_YYerror = 1, /* error */ - YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ - YYSYMBOL_IDENT = 3, /* IDENT */ - YYSYMBOL_FCONST = 4, /* FCONST */ - YYSYMBOL_SCONST = 5, /* SCONST */ - YYSYMBOL_BCONST = 6, /* BCONST */ - YYSYMBOL_XCONST = 7, /* XCONST */ - YYSYMBOL_Op = 8, /* Op */ - YYSYMBOL_ICONST = 9, /* ICONST */ - YYSYMBOL_PARAM = 10, /* PARAM */ - YYSYMBOL_TYPECAST = 11, /* TYPECAST */ - YYSYMBOL_DOT_DOT = 12, /* DOT_DOT */ - YYSYMBOL_COLON_EQUALS = 13, /* COLON_EQUALS */ - YYSYMBOL_EQUALS_GREATER = 14, /* EQUALS_GREATER */ - YYSYMBOL_INTEGER_DIVISION = 15, /* INTEGER_DIVISION */ - YYSYMBOL_POWER_OF = 16, /* POWER_OF */ - YYSYMBOL_LAMBDA_ARROW = 17, /* LAMBDA_ARROW */ - YYSYMBOL_DOUBLE_ARROW = 18, /* DOUBLE_ARROW */ - YYSYMBOL_LESS_EQUALS = 19, /* LESS_EQUALS */ - YYSYMBOL_GREATER_EQUALS = 20, /* GREATER_EQUALS */ - YYSYMBOL_NOT_EQUALS = 21, /* NOT_EQUALS */ - YYSYMBOL_ABORT_P = 22, /* ABORT_P */ - YYSYMBOL_ABSOLUTE_P = 23, /* ABSOLUTE_P */ - YYSYMBOL_ACCESS = 24, /* ACCESS */ - YYSYMBOL_ACTION = 25, /* ACTION */ - YYSYMBOL_ADD_P = 26, /* ADD_P */ - YYSYMBOL_ADMIN = 27, /* ADMIN */ - YYSYMBOL_AFTER = 28, /* AFTER */ - YYSYMBOL_AGGREGATE = 29, /* AGGREGATE */ - YYSYMBOL_ALL = 30, /* ALL */ - YYSYMBOL_ALSO = 31, /* ALSO */ - YYSYMBOL_ALTER = 32, /* ALTER */ - YYSYMBOL_ALWAYS = 33, /* ALWAYS */ - YYSYMBOL_ANALYSE = 34, /* ANALYSE */ - YYSYMBOL_ANALYZE = 35, /* ANALYZE */ - YYSYMBOL_AND = 36, /* AND */ - YYSYMBOL_ANTI = 37, /* ANTI */ - YYSYMBOL_ANY = 38, /* ANY */ - YYSYMBOL_ARRAY = 39, /* ARRAY */ - YYSYMBOL_AS = 40, /* AS */ - YYSYMBOL_ASC_P = 41, /* ASC_P */ - YYSYMBOL_ASOF = 42, /* ASOF */ - YYSYMBOL_ASSERTION = 43, /* ASSERTION */ - YYSYMBOL_ASSIGNMENT = 44, /* ASSIGNMENT */ - YYSYMBOL_ASYMMETRIC = 45, /* ASYMMETRIC */ - YYSYMBOL_AT = 46, /* AT */ - YYSYMBOL_ATTACH = 47, /* ATTACH */ - YYSYMBOL_ATTRIBUTE = 48, /* ATTRIBUTE */ - YYSYMBOL_AUTHORIZATION = 49, /* AUTHORIZATION */ - YYSYMBOL_BACKWARD = 50, /* BACKWARD */ - YYSYMBOL_BEFORE = 51, /* BEFORE */ - YYSYMBOL_BEGIN_P = 52, /* BEGIN_P */ - YYSYMBOL_BETWEEN = 53, /* BETWEEN */ - YYSYMBOL_BIGINT = 54, /* BIGINT */ - YYSYMBOL_BINARY = 55, /* BINARY */ - YYSYMBOL_BIT = 56, /* BIT */ - YYSYMBOL_BOOLEAN_P = 57, /* BOOLEAN_P */ - YYSYMBOL_BOTH = 58, /* BOTH */ - YYSYMBOL_BY = 59, /* BY */ - YYSYMBOL_CACHE = 60, /* CACHE */ - YYSYMBOL_CALL_P = 61, /* CALL_P */ - YYSYMBOL_CALLED = 62, /* CALLED */ - YYSYMBOL_CASCADE = 63, /* CASCADE */ - YYSYMBOL_CASCADED = 64, /* CASCADED */ - YYSYMBOL_CASE = 65, /* CASE */ - YYSYMBOL_CAST = 66, /* CAST */ - YYSYMBOL_CATALOG_P = 67, /* CATALOG_P */ - YYSYMBOL_CENTURIES_P = 68, /* CENTURIES_P */ - YYSYMBOL_CENTURY_P = 69, /* CENTURY_P */ - YYSYMBOL_CHAIN = 70, /* CHAIN */ - YYSYMBOL_CHAR_P = 71, /* CHAR_P */ - YYSYMBOL_CHARACTER = 72, /* CHARACTER */ - YYSYMBOL_CHARACTERISTICS = 73, /* CHARACTERISTICS */ - YYSYMBOL_CHECK_P = 74, /* CHECK_P */ - YYSYMBOL_CHECKPOINT = 75, /* CHECKPOINT */ - YYSYMBOL_CLASS = 76, /* CLASS */ - YYSYMBOL_CLOSE = 77, /* CLOSE */ - YYSYMBOL_CLUSTER = 78, /* CLUSTER */ - YYSYMBOL_COALESCE = 79, /* COALESCE */ - YYSYMBOL_COLLATE = 80, /* COLLATE */ - YYSYMBOL_COLLATION = 81, /* COLLATION */ - YYSYMBOL_COLUMN = 82, /* COLUMN */ - YYSYMBOL_COLUMNS = 83, /* COLUMNS */ - YYSYMBOL_COMMENT = 84, /* COMMENT */ - YYSYMBOL_COMMENTS = 85, /* COMMENTS */ - YYSYMBOL_COMMIT = 86, /* COMMIT */ - YYSYMBOL_COMMITTED = 87, /* COMMITTED */ - YYSYMBOL_COMPRESSION = 88, /* COMPRESSION */ - YYSYMBOL_CONCURRENTLY = 89, /* CONCURRENTLY */ - YYSYMBOL_CONFIGURATION = 90, /* CONFIGURATION */ - YYSYMBOL_CONFLICT = 91, /* CONFLICT */ - YYSYMBOL_CONNECTION = 92, /* CONNECTION */ - YYSYMBOL_CONSTRAINT = 93, /* CONSTRAINT */ - YYSYMBOL_CONSTRAINTS = 94, /* CONSTRAINTS */ - YYSYMBOL_CONTENT_P = 95, /* CONTENT_P */ - YYSYMBOL_CONTINUE_P = 96, /* CONTINUE_P */ - YYSYMBOL_CONVERSION_P = 97, /* CONVERSION_P */ - YYSYMBOL_COPY = 98, /* COPY */ - YYSYMBOL_COST = 99, /* COST */ - YYSYMBOL_CREATE_P = 100, /* CREATE_P */ - YYSYMBOL_CROSS = 101, /* CROSS */ - YYSYMBOL_CSV = 102, /* CSV */ - YYSYMBOL_CUBE = 103, /* CUBE */ - YYSYMBOL_CURRENT_P = 104, /* CURRENT_P */ - YYSYMBOL_CURSOR = 105, /* CURSOR */ - YYSYMBOL_CYCLE = 106, /* CYCLE */ - YYSYMBOL_DATA_P = 107, /* DATA_P */ - YYSYMBOL_DATABASE = 108, /* DATABASE */ - YYSYMBOL_DAY_P = 109, /* DAY_P */ - YYSYMBOL_DAYS_P = 110, /* DAYS_P */ - YYSYMBOL_DEALLOCATE = 111, /* DEALLOCATE */ - YYSYMBOL_DEC = 112, /* DEC */ - YYSYMBOL_DECADE_P = 113, /* DECADE_P */ - YYSYMBOL_DECADES_P = 114, /* DECADES_P */ - YYSYMBOL_DECIMAL_P = 115, /* DECIMAL_P */ - YYSYMBOL_DECLARE = 116, /* DECLARE */ - YYSYMBOL_DEFAULT = 117, /* DEFAULT */ - YYSYMBOL_DEFAULTS = 118, /* DEFAULTS */ - YYSYMBOL_DEFERRABLE = 119, /* DEFERRABLE */ - YYSYMBOL_DEFERRED = 120, /* DEFERRED */ - YYSYMBOL_DEFINER = 121, /* DEFINER */ - YYSYMBOL_DELETE_P = 122, /* DELETE_P */ - YYSYMBOL_DELIMITER = 123, /* DELIMITER */ - YYSYMBOL_DELIMITERS = 124, /* DELIMITERS */ - YYSYMBOL_DEPENDS = 125, /* DEPENDS */ - YYSYMBOL_DESC_P = 126, /* DESC_P */ - YYSYMBOL_DESCRIBE = 127, /* DESCRIBE */ - YYSYMBOL_DETACH = 128, /* DETACH */ - YYSYMBOL_DICTIONARY = 129, /* DICTIONARY */ - YYSYMBOL_DISABLE_P = 130, /* DISABLE_P */ - YYSYMBOL_DISCARD = 131, /* DISCARD */ - YYSYMBOL_DISTINCT = 132, /* DISTINCT */ - YYSYMBOL_DO = 133, /* DO */ - YYSYMBOL_DOCUMENT_P = 134, /* DOCUMENT_P */ - YYSYMBOL_DOMAIN_P = 135, /* DOMAIN_P */ - YYSYMBOL_DOUBLE_P = 136, /* DOUBLE_P */ - YYSYMBOL_DROP = 137, /* DROP */ - YYSYMBOL_EACH = 138, /* EACH */ - YYSYMBOL_ELSE = 139, /* ELSE */ - YYSYMBOL_ENABLE_P = 140, /* ENABLE_P */ - YYSYMBOL_ENCODING = 141, /* ENCODING */ - YYSYMBOL_ENCRYPTED = 142, /* ENCRYPTED */ - YYSYMBOL_END_P = 143, /* END_P */ - YYSYMBOL_ENUM_P = 144, /* ENUM_P */ - YYSYMBOL_ESCAPE = 145, /* ESCAPE */ - YYSYMBOL_EVENT = 146, /* EVENT */ - YYSYMBOL_EXCEPT = 147, /* EXCEPT */ - YYSYMBOL_EXCLUDE = 148, /* EXCLUDE */ - YYSYMBOL_EXCLUDING = 149, /* EXCLUDING */ - YYSYMBOL_EXCLUSIVE = 150, /* EXCLUSIVE */ - YYSYMBOL_EXECUTE = 151, /* EXECUTE */ - YYSYMBOL_EXISTS = 152, /* EXISTS */ - YYSYMBOL_EXPLAIN = 153, /* EXPLAIN */ - YYSYMBOL_EXPORT_P = 154, /* EXPORT_P */ - YYSYMBOL_EXPORT_STATE = 155, /* EXPORT_STATE */ - YYSYMBOL_EXTENSION = 156, /* EXTENSION */ - YYSYMBOL_EXTERNAL = 157, /* EXTERNAL */ - YYSYMBOL_EXTRACT = 158, /* EXTRACT */ - YYSYMBOL_FALSE_P = 159, /* FALSE_P */ - YYSYMBOL_FAMILY = 160, /* FAMILY */ - YYSYMBOL_FETCH = 161, /* FETCH */ - YYSYMBOL_FILTER = 162, /* FILTER */ - YYSYMBOL_FIRST_P = 163, /* FIRST_P */ - YYSYMBOL_FLOAT_P = 164, /* FLOAT_P */ - YYSYMBOL_FOLLOWING = 165, /* FOLLOWING */ - YYSYMBOL_FOR = 166, /* FOR */ - YYSYMBOL_FORCE = 167, /* FORCE */ - YYSYMBOL_FOREIGN = 168, /* FOREIGN */ - YYSYMBOL_FORWARD = 169, /* FORWARD */ - YYSYMBOL_FREEZE = 170, /* FREEZE */ - YYSYMBOL_FROM = 171, /* FROM */ - YYSYMBOL_FULL = 172, /* FULL */ - YYSYMBOL_FUNCTION = 173, /* FUNCTION */ - YYSYMBOL_FUNCTIONS = 174, /* FUNCTIONS */ - YYSYMBOL_GENERATED = 175, /* GENERATED */ - YYSYMBOL_GLOB = 176, /* GLOB */ - YYSYMBOL_GLOBAL = 177, /* GLOBAL */ - YYSYMBOL_GRANT = 178, /* GRANT */ - YYSYMBOL_GRANTED = 179, /* GRANTED */ - YYSYMBOL_GROUP_P = 180, /* GROUP_P */ - YYSYMBOL_GROUPING = 181, /* GROUPING */ - YYSYMBOL_GROUPING_ID = 182, /* GROUPING_ID */ - YYSYMBOL_GROUPS = 183, /* GROUPS */ - YYSYMBOL_HANDLER = 184, /* HANDLER */ - YYSYMBOL_HAVING = 185, /* HAVING */ - YYSYMBOL_HEADER_P = 186, /* HEADER_P */ - YYSYMBOL_HOLD = 187, /* HOLD */ - YYSYMBOL_HOUR_P = 188, /* HOUR_P */ - YYSYMBOL_HOURS_P = 189, /* HOURS_P */ - YYSYMBOL_IDENTITY_P = 190, /* IDENTITY_P */ - YYSYMBOL_IF_P = 191, /* IF_P */ - YYSYMBOL_IGNORE_P = 192, /* IGNORE_P */ - YYSYMBOL_ILIKE = 193, /* ILIKE */ - YYSYMBOL_IMMEDIATE = 194, /* IMMEDIATE */ - YYSYMBOL_IMMUTABLE = 195, /* IMMUTABLE */ - YYSYMBOL_IMPLICIT_P = 196, /* IMPLICIT_P */ - YYSYMBOL_IMPORT_P = 197, /* IMPORT_P */ - YYSYMBOL_IN_P = 198, /* IN_P */ - YYSYMBOL_INCLUDE_P = 199, /* INCLUDE_P */ - YYSYMBOL_INCLUDING = 200, /* INCLUDING */ - YYSYMBOL_INCREMENT = 201, /* INCREMENT */ - YYSYMBOL_INDEX = 202, /* INDEX */ - YYSYMBOL_INDEXES = 203, /* INDEXES */ - YYSYMBOL_INHERIT = 204, /* INHERIT */ - YYSYMBOL_INHERITS = 205, /* INHERITS */ - YYSYMBOL_INITIALLY = 206, /* INITIALLY */ - YYSYMBOL_INLINE_P = 207, /* INLINE_P */ - YYSYMBOL_INNER_P = 208, /* INNER_P */ - YYSYMBOL_INOUT = 209, /* INOUT */ - YYSYMBOL_INPUT_P = 210, /* INPUT_P */ - YYSYMBOL_INSENSITIVE = 211, /* INSENSITIVE */ - YYSYMBOL_INSERT = 212, /* INSERT */ - YYSYMBOL_INSTALL = 213, /* INSTALL */ - YYSYMBOL_INSTEAD = 214, /* INSTEAD */ - YYSYMBOL_INT_P = 215, /* INT_P */ - YYSYMBOL_INTEGER = 216, /* INTEGER */ - YYSYMBOL_INTERSECT = 217, /* INTERSECT */ - YYSYMBOL_INTERVAL = 218, /* INTERVAL */ - YYSYMBOL_INTO = 219, /* INTO */ - YYSYMBOL_INVOKER = 220, /* INVOKER */ - YYSYMBOL_IS = 221, /* IS */ - YYSYMBOL_ISNULL = 222, /* ISNULL */ - YYSYMBOL_ISOLATION = 223, /* ISOLATION */ - YYSYMBOL_JOIN = 224, /* JOIN */ - YYSYMBOL_JSON = 225, /* JSON */ - YYSYMBOL_KEY = 226, /* KEY */ - YYSYMBOL_LABEL = 227, /* LABEL */ - YYSYMBOL_LANGUAGE = 228, /* LANGUAGE */ - YYSYMBOL_LARGE_P = 229, /* LARGE_P */ - YYSYMBOL_LAST_P = 230, /* LAST_P */ - YYSYMBOL_LATERAL_P = 231, /* LATERAL_P */ - YYSYMBOL_LEADING = 232, /* LEADING */ - YYSYMBOL_LEAKPROOF = 233, /* LEAKPROOF */ - YYSYMBOL_LEFT = 234, /* LEFT */ - YYSYMBOL_LEVEL = 235, /* LEVEL */ - YYSYMBOL_LIKE = 236, /* LIKE */ - YYSYMBOL_LIMIT = 237, /* LIMIT */ - YYSYMBOL_LISTEN = 238, /* LISTEN */ - YYSYMBOL_LOAD = 239, /* LOAD */ - YYSYMBOL_LOCAL = 240, /* LOCAL */ - YYSYMBOL_LOCATION = 241, /* LOCATION */ - YYSYMBOL_LOCK_P = 242, /* LOCK_P */ - YYSYMBOL_LOCKED = 243, /* LOCKED */ - YYSYMBOL_LOGGED = 244, /* LOGGED */ - YYSYMBOL_MACRO = 245, /* MACRO */ - YYSYMBOL_MAP = 246, /* MAP */ - YYSYMBOL_MAPPING = 247, /* MAPPING */ - YYSYMBOL_MATCH = 248, /* MATCH */ - YYSYMBOL_MATERIALIZED = 249, /* MATERIALIZED */ - YYSYMBOL_MAXVALUE = 250, /* MAXVALUE */ - YYSYMBOL_METHOD = 251, /* METHOD */ - YYSYMBOL_MICROSECOND_P = 252, /* MICROSECOND_P */ - YYSYMBOL_MICROSECONDS_P = 253, /* MICROSECONDS_P */ - YYSYMBOL_MILLENNIA_P = 254, /* MILLENNIA_P */ - YYSYMBOL_MILLENNIUM_P = 255, /* MILLENNIUM_P */ - YYSYMBOL_MILLISECOND_P = 256, /* MILLISECOND_P */ - YYSYMBOL_MILLISECONDS_P = 257, /* MILLISECONDS_P */ - YYSYMBOL_MINUTE_P = 258, /* MINUTE_P */ - YYSYMBOL_MINUTES_P = 259, /* MINUTES_P */ - YYSYMBOL_MINVALUE = 260, /* MINVALUE */ - YYSYMBOL_MODE = 261, /* MODE */ - YYSYMBOL_MONTH_P = 262, /* MONTH_P */ - YYSYMBOL_MONTHS_P = 263, /* MONTHS_P */ - YYSYMBOL_MOVE = 264, /* MOVE */ - YYSYMBOL_NAME_P = 265, /* NAME_P */ - YYSYMBOL_NAMES = 266, /* NAMES */ - YYSYMBOL_NATIONAL = 267, /* NATIONAL */ - YYSYMBOL_NATURAL = 268, /* NATURAL */ - YYSYMBOL_NCHAR = 269, /* NCHAR */ - YYSYMBOL_NEW = 270, /* NEW */ - YYSYMBOL_NEXT = 271, /* NEXT */ - YYSYMBOL_NO = 272, /* NO */ - YYSYMBOL_NONE = 273, /* NONE */ - YYSYMBOL_NOT = 274, /* NOT */ - YYSYMBOL_NOTHING = 275, /* NOTHING */ - YYSYMBOL_NOTIFY = 276, /* NOTIFY */ - YYSYMBOL_NOTNULL = 277, /* NOTNULL */ - YYSYMBOL_NOWAIT = 278, /* NOWAIT */ - YYSYMBOL_NULL_P = 279, /* NULL_P */ - YYSYMBOL_NULLIF = 280, /* NULLIF */ - YYSYMBOL_NULLS_P = 281, /* NULLS_P */ - YYSYMBOL_NUMERIC = 282, /* NUMERIC */ - YYSYMBOL_OBJECT_P = 283, /* OBJECT_P */ - YYSYMBOL_OF = 284, /* OF */ - YYSYMBOL_OFF = 285, /* OFF */ - YYSYMBOL_OFFSET = 286, /* OFFSET */ - YYSYMBOL_OIDS = 287, /* OIDS */ - YYSYMBOL_OLD = 288, /* OLD */ - YYSYMBOL_ON = 289, /* ON */ - YYSYMBOL_ONLY = 290, /* ONLY */ - YYSYMBOL_OPERATOR = 291, /* OPERATOR */ - YYSYMBOL_OPTION = 292, /* OPTION */ - YYSYMBOL_OPTIONS = 293, /* OPTIONS */ - YYSYMBOL_OR = 294, /* OR */ - YYSYMBOL_ORDER = 295, /* ORDER */ - YYSYMBOL_ORDINALITY = 296, /* ORDINALITY */ - YYSYMBOL_OTHERS = 297, /* OTHERS */ - YYSYMBOL_OUT_P = 298, /* OUT_P */ - YYSYMBOL_OUTER_P = 299, /* OUTER_P */ - YYSYMBOL_OVER = 300, /* OVER */ - YYSYMBOL_OVERLAPS = 301, /* OVERLAPS */ - YYSYMBOL_OVERLAY = 302, /* OVERLAY */ - YYSYMBOL_OVERRIDING = 303, /* OVERRIDING */ - YYSYMBOL_OWNED = 304, /* OWNED */ - YYSYMBOL_OWNER = 305, /* OWNER */ - YYSYMBOL_PARALLEL = 306, /* PARALLEL */ - YYSYMBOL_PARSER = 307, /* PARSER */ - YYSYMBOL_PARTIAL = 308, /* PARTIAL */ - YYSYMBOL_PARTITION = 309, /* PARTITION */ - YYSYMBOL_PASSING = 310, /* PASSING */ - YYSYMBOL_PASSWORD = 311, /* PASSWORD */ - YYSYMBOL_PERCENT = 312, /* PERCENT */ - YYSYMBOL_PERSISTENT = 313, /* PERSISTENT */ - YYSYMBOL_PIVOT = 314, /* PIVOT */ - YYSYMBOL_PIVOT_LONGER = 315, /* PIVOT_LONGER */ - YYSYMBOL_PIVOT_WIDER = 316, /* PIVOT_WIDER */ - YYSYMBOL_PLACING = 317, /* PLACING */ - YYSYMBOL_PLANS = 318, /* PLANS */ - YYSYMBOL_POLICY = 319, /* POLICY */ - YYSYMBOL_POSITION = 320, /* POSITION */ - YYSYMBOL_POSITIONAL = 321, /* POSITIONAL */ - YYSYMBOL_PRAGMA_P = 322, /* PRAGMA_P */ - YYSYMBOL_PRECEDING = 323, /* PRECEDING */ - YYSYMBOL_PRECISION = 324, /* PRECISION */ - YYSYMBOL_PREPARE = 325, /* PREPARE */ - YYSYMBOL_PREPARED = 326, /* PREPARED */ - YYSYMBOL_PRESERVE = 327, /* PRESERVE */ - YYSYMBOL_PRIMARY = 328, /* PRIMARY */ - YYSYMBOL_PRIOR = 329, /* PRIOR */ - YYSYMBOL_PRIVILEGES = 330, /* PRIVILEGES */ - YYSYMBOL_PROCEDURAL = 331, /* PROCEDURAL */ - YYSYMBOL_PROCEDURE = 332, /* PROCEDURE */ - YYSYMBOL_PROGRAM = 333, /* PROGRAM */ - YYSYMBOL_PUBLICATION = 334, /* PUBLICATION */ - YYSYMBOL_QUALIFY = 335, /* QUALIFY */ - YYSYMBOL_QUOTE = 336, /* QUOTE */ - YYSYMBOL_RANGE = 337, /* RANGE */ - YYSYMBOL_READ_P = 338, /* READ_P */ - YYSYMBOL_REAL = 339, /* REAL */ - YYSYMBOL_REASSIGN = 340, /* REASSIGN */ - YYSYMBOL_RECHECK = 341, /* RECHECK */ - YYSYMBOL_RECURSIVE = 342, /* RECURSIVE */ - YYSYMBOL_REF = 343, /* REF */ - YYSYMBOL_REFERENCES = 344, /* REFERENCES */ - YYSYMBOL_REFERENCING = 345, /* REFERENCING */ - YYSYMBOL_REFRESH = 346, /* REFRESH */ - YYSYMBOL_REINDEX = 347, /* REINDEX */ - YYSYMBOL_RELATIVE_P = 348, /* RELATIVE_P */ - YYSYMBOL_RELEASE = 349, /* RELEASE */ - YYSYMBOL_RENAME = 350, /* RENAME */ - YYSYMBOL_REPEATABLE = 351, /* REPEATABLE */ - YYSYMBOL_REPLACE = 352, /* REPLACE */ - YYSYMBOL_REPLICA = 353, /* REPLICA */ - YYSYMBOL_RESET = 354, /* RESET */ - YYSYMBOL_RESPECT_P = 355, /* RESPECT_P */ - YYSYMBOL_RESTART = 356, /* RESTART */ - YYSYMBOL_RESTRICT = 357, /* RESTRICT */ - YYSYMBOL_RETURNING = 358, /* RETURNING */ - YYSYMBOL_RETURNS = 359, /* RETURNS */ - YYSYMBOL_REVOKE = 360, /* REVOKE */ - YYSYMBOL_RIGHT = 361, /* RIGHT */ - YYSYMBOL_ROLE = 362, /* ROLE */ - YYSYMBOL_ROLLBACK = 363, /* ROLLBACK */ - YYSYMBOL_ROLLUP = 364, /* ROLLUP */ - YYSYMBOL_ROW = 365, /* ROW */ - YYSYMBOL_ROWS = 366, /* ROWS */ - YYSYMBOL_RULE = 367, /* RULE */ - YYSYMBOL_SAMPLE = 368, /* SAMPLE */ - YYSYMBOL_SAVEPOINT = 369, /* SAVEPOINT */ - YYSYMBOL_SCHEMA = 370, /* SCHEMA */ - YYSYMBOL_SCHEMAS = 371, /* SCHEMAS */ - YYSYMBOL_SCOPE = 372, /* SCOPE */ - YYSYMBOL_SCROLL = 373, /* SCROLL */ - YYSYMBOL_SEARCH = 374, /* SEARCH */ - YYSYMBOL_SECOND_P = 375, /* SECOND_P */ - YYSYMBOL_SECONDS_P = 376, /* SECONDS_P */ - YYSYMBOL_SECRET = 377, /* SECRET */ - YYSYMBOL_SECURITY = 378, /* SECURITY */ - YYSYMBOL_SELECT = 379, /* SELECT */ - YYSYMBOL_SEMI = 380, /* SEMI */ - YYSYMBOL_SEQUENCE = 381, /* SEQUENCE */ - YYSYMBOL_SEQUENCES = 382, /* SEQUENCES */ - YYSYMBOL_SERIALIZABLE = 383, /* SERIALIZABLE */ - YYSYMBOL_SERVER = 384, /* SERVER */ - YYSYMBOL_SESSION = 385, /* SESSION */ - YYSYMBOL_SET = 386, /* SET */ - YYSYMBOL_SETOF = 387, /* SETOF */ - YYSYMBOL_SETS = 388, /* SETS */ - YYSYMBOL_SHARE = 389, /* SHARE */ - YYSYMBOL_SHOW = 390, /* SHOW */ - YYSYMBOL_SIMILAR = 391, /* SIMILAR */ - YYSYMBOL_SIMPLE = 392, /* SIMPLE */ - YYSYMBOL_SKIP = 393, /* SKIP */ - YYSYMBOL_SMALLINT = 394, /* SMALLINT */ - YYSYMBOL_SNAPSHOT = 395, /* SNAPSHOT */ - YYSYMBOL_SOME = 396, /* SOME */ - YYSYMBOL_SQL_P = 397, /* SQL_P */ - YYSYMBOL_STABLE = 398, /* STABLE */ - YYSYMBOL_STANDALONE_P = 399, /* STANDALONE_P */ - YYSYMBOL_START = 400, /* START */ - YYSYMBOL_STATEMENT = 401, /* STATEMENT */ - YYSYMBOL_STATISTICS = 402, /* STATISTICS */ - YYSYMBOL_STDIN = 403, /* STDIN */ - YYSYMBOL_STDOUT = 404, /* STDOUT */ - YYSYMBOL_STORAGE = 405, /* STORAGE */ - YYSYMBOL_STORED = 406, /* STORED */ - YYSYMBOL_STRICT_P = 407, /* STRICT_P */ - YYSYMBOL_STRIP_P = 408, /* STRIP_P */ - YYSYMBOL_STRUCT = 409, /* STRUCT */ - YYSYMBOL_SUBSCRIPTION = 410, /* SUBSCRIPTION */ - YYSYMBOL_SUBSTRING = 411, /* SUBSTRING */ - YYSYMBOL_SUMMARIZE = 412, /* SUMMARIZE */ - YYSYMBOL_SYMMETRIC = 413, /* SYMMETRIC */ - YYSYMBOL_SYSID = 414, /* SYSID */ - YYSYMBOL_SYSTEM_P = 415, /* SYSTEM_P */ - YYSYMBOL_TABLE = 416, /* TABLE */ - YYSYMBOL_TABLES = 417, /* TABLES */ - YYSYMBOL_TABLESAMPLE = 418, /* TABLESAMPLE */ - YYSYMBOL_TABLESPACE = 419, /* TABLESPACE */ - YYSYMBOL_TEMP = 420, /* TEMP */ - YYSYMBOL_TEMPLATE = 421, /* TEMPLATE */ - YYSYMBOL_TEMPORARY = 422, /* TEMPORARY */ - YYSYMBOL_TEXT_P = 423, /* TEXT_P */ - YYSYMBOL_THEN = 424, /* THEN */ - YYSYMBOL_TIES = 425, /* TIES */ - YYSYMBOL_TIME = 426, /* TIME */ - YYSYMBOL_TIMESTAMP = 427, /* TIMESTAMP */ - YYSYMBOL_TO = 428, /* TO */ - YYSYMBOL_TRAILING = 429, /* TRAILING */ - YYSYMBOL_TRANSACTION = 430, /* TRANSACTION */ - YYSYMBOL_TRANSFORM = 431, /* TRANSFORM */ - YYSYMBOL_TREAT = 432, /* TREAT */ - YYSYMBOL_TRIGGER = 433, /* TRIGGER */ - YYSYMBOL_TRIM = 434, /* TRIM */ - YYSYMBOL_TRUE_P = 435, /* TRUE_P */ - YYSYMBOL_TRUNCATE = 436, /* TRUNCATE */ - YYSYMBOL_TRUSTED = 437, /* TRUSTED */ - YYSYMBOL_TRY_CAST = 438, /* TRY_CAST */ - YYSYMBOL_TYPE_P = 439, /* TYPE_P */ - YYSYMBOL_TYPES_P = 440, /* TYPES_P */ - YYSYMBOL_UNBOUNDED = 441, /* UNBOUNDED */ - YYSYMBOL_UNCOMMITTED = 442, /* UNCOMMITTED */ - YYSYMBOL_UNENCRYPTED = 443, /* UNENCRYPTED */ - YYSYMBOL_UNION = 444, /* UNION */ - YYSYMBOL_UNIQUE = 445, /* UNIQUE */ - YYSYMBOL_UNKNOWN = 446, /* UNKNOWN */ - YYSYMBOL_UNLISTEN = 447, /* UNLISTEN */ - YYSYMBOL_UNLOGGED = 448, /* UNLOGGED */ - YYSYMBOL_UNPIVOT = 449, /* UNPIVOT */ - YYSYMBOL_UNTIL = 450, /* UNTIL */ - YYSYMBOL_UPDATE = 451, /* UPDATE */ - YYSYMBOL_USE_P = 452, /* USE_P */ - YYSYMBOL_USER = 453, /* USER */ - YYSYMBOL_USING = 454, /* USING */ - YYSYMBOL_VACUUM = 455, /* VACUUM */ - YYSYMBOL_VALID = 456, /* VALID */ - YYSYMBOL_VALIDATE = 457, /* VALIDATE */ - YYSYMBOL_VALIDATOR = 458, /* VALIDATOR */ - YYSYMBOL_VALUE_P = 459, /* VALUE_P */ - YYSYMBOL_VALUES = 460, /* VALUES */ - YYSYMBOL_VARCHAR = 461, /* VARCHAR */ - YYSYMBOL_VARIADIC = 462, /* VARIADIC */ - YYSYMBOL_VARYING = 463, /* VARYING */ - YYSYMBOL_VERBOSE = 464, /* VERBOSE */ - YYSYMBOL_VERSION_P = 465, /* VERSION_P */ - YYSYMBOL_VIEW = 466, /* VIEW */ - YYSYMBOL_VIEWS = 467, /* VIEWS */ - YYSYMBOL_VIRTUAL = 468, /* VIRTUAL */ - YYSYMBOL_VOLATILE = 469, /* VOLATILE */ - YYSYMBOL_WEEK_P = 470, /* WEEK_P */ - YYSYMBOL_WEEKS_P = 471, /* WEEKS_P */ - YYSYMBOL_WHEN = 472, /* WHEN */ - YYSYMBOL_WHERE = 473, /* WHERE */ - YYSYMBOL_WHITESPACE_P = 474, /* WHITESPACE_P */ - YYSYMBOL_WINDOW = 475, /* WINDOW */ - YYSYMBOL_WITH = 476, /* WITH */ - YYSYMBOL_WITHIN = 477, /* WITHIN */ - YYSYMBOL_WITHOUT = 478, /* WITHOUT */ - YYSYMBOL_WORK = 479, /* WORK */ - YYSYMBOL_WRAPPER = 480, /* WRAPPER */ - YYSYMBOL_WRITE_P = 481, /* WRITE_P */ - YYSYMBOL_XML_P = 482, /* XML_P */ - YYSYMBOL_XMLATTRIBUTES = 483, /* XMLATTRIBUTES */ - YYSYMBOL_XMLCONCAT = 484, /* XMLCONCAT */ - YYSYMBOL_XMLELEMENT = 485, /* XMLELEMENT */ - YYSYMBOL_XMLEXISTS = 486, /* XMLEXISTS */ - YYSYMBOL_XMLFOREST = 487, /* XMLFOREST */ - YYSYMBOL_XMLNAMESPACES = 488, /* XMLNAMESPACES */ - YYSYMBOL_XMLPARSE = 489, /* XMLPARSE */ - YYSYMBOL_XMLPI = 490, /* XMLPI */ - YYSYMBOL_XMLROOT = 491, /* XMLROOT */ - YYSYMBOL_XMLSERIALIZE = 492, /* XMLSERIALIZE */ - YYSYMBOL_XMLTABLE = 493, /* XMLTABLE */ - YYSYMBOL_YEAR_P = 494, /* YEAR_P */ - YYSYMBOL_YEARS_P = 495, /* YEARS_P */ - YYSYMBOL_YES_P = 496, /* YES_P */ - YYSYMBOL_ZONE = 497, /* ZONE */ - YYSYMBOL_NOT_LA = 498, /* NOT_LA */ - YYSYMBOL_NULLS_LA = 499, /* NULLS_LA */ - YYSYMBOL_WITH_LA = 500, /* WITH_LA */ - YYSYMBOL_501_ = 501, /* '<' */ - YYSYMBOL_502_ = 502, /* '>' */ - YYSYMBOL_503_ = 503, /* '=' */ - YYSYMBOL_POSTFIXOP = 504, /* POSTFIXOP */ - YYSYMBOL_505_ = 505, /* '+' */ - YYSYMBOL_506_ = 506, /* '-' */ - YYSYMBOL_507_ = 507, /* '*' */ - YYSYMBOL_508_ = 508, /* '/' */ - YYSYMBOL_509_ = 509, /* '%' */ - YYSYMBOL_510_ = 510, /* '^' */ - YYSYMBOL_UMINUS = 511, /* UMINUS */ - YYSYMBOL_512_ = 512, /* '[' */ - YYSYMBOL_513_ = 513, /* ']' */ - YYSYMBOL_514_ = 514, /* '(' */ - YYSYMBOL_515_ = 515, /* ')' */ - YYSYMBOL_516_ = 516, /* '.' */ - YYSYMBOL_517_ = 517, /* ';' */ - YYSYMBOL_518_ = 518, /* ',' */ - YYSYMBOL_519_ = 519, /* '#' */ - YYSYMBOL_520_ = 520, /* '$' */ - YYSYMBOL_521_ = 521, /* '?' */ - YYSYMBOL_522_ = 522, /* '{' */ - YYSYMBOL_523_ = 523, /* '}' */ - YYSYMBOL_524_ = 524, /* ':' */ - YYSYMBOL_YYACCEPT = 525, /* $accept */ - YYSYMBOL_stmtblock = 526, /* stmtblock */ - YYSYMBOL_stmtmulti = 527, /* stmtmulti */ - YYSYMBOL_stmt = 528, /* stmt */ - YYSYMBOL_AlterObjectSchemaStmt = 529, /* AlterObjectSchemaStmt */ - YYSYMBOL_AlterSeqStmt = 530, /* AlterSeqStmt */ - YYSYMBOL_SeqOptList = 531, /* SeqOptList */ - YYSYMBOL_opt_with = 532, /* opt_with */ - YYSYMBOL_NumericOnly = 533, /* NumericOnly */ - YYSYMBOL_SeqOptElem = 534, /* SeqOptElem */ - YYSYMBOL_opt_by = 535, /* opt_by */ - YYSYMBOL_SignedIconst = 536, /* SignedIconst */ - YYSYMBOL_AlterTableStmt = 537, /* AlterTableStmt */ - YYSYMBOL_alter_identity_column_option_list = 538, /* alter_identity_column_option_list */ - YYSYMBOL_alter_column_default = 539, /* alter_column_default */ - YYSYMBOL_alter_identity_column_option = 540, /* alter_identity_column_option */ - YYSYMBOL_alter_generic_option_list = 541, /* alter_generic_option_list */ - YYSYMBOL_alter_table_cmd = 542, /* alter_table_cmd */ - YYSYMBOL_alter_using = 543, /* alter_using */ - YYSYMBOL_alter_generic_option_elem = 544, /* alter_generic_option_elem */ - YYSYMBOL_alter_table_cmds = 545, /* alter_table_cmds */ - YYSYMBOL_alter_generic_options = 546, /* alter_generic_options */ - YYSYMBOL_opt_set_data = 547, /* opt_set_data */ - YYSYMBOL_AnalyzeStmt = 548, /* AnalyzeStmt */ - YYSYMBOL_AttachStmt = 549, /* AttachStmt */ - YYSYMBOL_DetachStmt = 550, /* DetachStmt */ - YYSYMBOL_opt_database = 551, /* opt_database */ - YYSYMBOL_opt_database_alias = 552, /* opt_database_alias */ - YYSYMBOL_CallStmt = 553, /* CallStmt */ - YYSYMBOL_CheckPointStmt = 554, /* CheckPointStmt */ - YYSYMBOL_opt_col_id = 555, /* opt_col_id */ - YYSYMBOL_CommentOnStmt = 556, /* CommentOnStmt */ - YYSYMBOL_comment_value = 557, /* comment_value */ - YYSYMBOL_comment_on_type_any_name = 558, /* comment_on_type_any_name */ - YYSYMBOL_qualified_name = 559, /* qualified_name */ - YYSYMBOL_ColId = 560, /* ColId */ - YYSYMBOL_ColIdOrString = 561, /* ColIdOrString */ - YYSYMBOL_Sconst = 562, /* Sconst */ - YYSYMBOL_indirection = 563, /* indirection */ - YYSYMBOL_indirection_el = 564, /* indirection_el */ - YYSYMBOL_attr_name = 565, /* attr_name */ - YYSYMBOL_ColLabel = 566, /* ColLabel */ - YYSYMBOL_CopyStmt = 567, /* CopyStmt */ - YYSYMBOL_copy_database_flag = 568, /* copy_database_flag */ - YYSYMBOL_copy_from = 569, /* copy_from */ - YYSYMBOL_copy_delimiter = 570, /* copy_delimiter */ - YYSYMBOL_copy_generic_opt_arg_list = 571, /* copy_generic_opt_arg_list */ - YYSYMBOL_opt_using = 572, /* opt_using */ - YYSYMBOL_opt_as = 573, /* opt_as */ - YYSYMBOL_opt_program = 574, /* opt_program */ - YYSYMBOL_copy_options = 575, /* copy_options */ - YYSYMBOL_copy_generic_opt_arg = 576, /* copy_generic_opt_arg */ - YYSYMBOL_copy_generic_opt_elem = 577, /* copy_generic_opt_elem */ - YYSYMBOL_opt_oids = 578, /* opt_oids */ - YYSYMBOL_copy_opt_list = 579, /* copy_opt_list */ - YYSYMBOL_opt_binary = 580, /* opt_binary */ - YYSYMBOL_copy_opt_item = 581, /* copy_opt_item */ - YYSYMBOL_copy_generic_opt_arg_list_item = 582, /* copy_generic_opt_arg_list_item */ - YYSYMBOL_copy_file_name = 583, /* copy_file_name */ - YYSYMBOL_copy_generic_opt_list = 584, /* copy_generic_opt_list */ - YYSYMBOL_CreateStmt = 585, /* CreateStmt */ - YYSYMBOL_ConstraintAttributeSpec = 586, /* ConstraintAttributeSpec */ - YYSYMBOL_def_arg = 587, /* def_arg */ - YYSYMBOL_OptParenthesizedSeqOptList = 588, /* OptParenthesizedSeqOptList */ - YYSYMBOL_generic_option_arg = 589, /* generic_option_arg */ - YYSYMBOL_key_action = 590, /* key_action */ - YYSYMBOL_ColConstraint = 591, /* ColConstraint */ - YYSYMBOL_ColConstraintElem = 592, /* ColConstraintElem */ - YYSYMBOL_GeneratedColumnType = 593, /* GeneratedColumnType */ - YYSYMBOL_opt_GeneratedColumnType = 594, /* opt_GeneratedColumnType */ - YYSYMBOL_GeneratedConstraintElem = 595, /* GeneratedConstraintElem */ - YYSYMBOL_generic_option_elem = 596, /* generic_option_elem */ - YYSYMBOL_key_update = 597, /* key_update */ - YYSYMBOL_key_actions = 598, /* key_actions */ - YYSYMBOL_OnCommitOption = 599, /* OnCommitOption */ - YYSYMBOL_reloptions = 600, /* reloptions */ - YYSYMBOL_opt_no_inherit = 601, /* opt_no_inherit */ - YYSYMBOL_TableConstraint = 602, /* TableConstraint */ - YYSYMBOL_TableLikeOption = 603, /* TableLikeOption */ - YYSYMBOL_reloption_list = 604, /* reloption_list */ - YYSYMBOL_ExistingIndex = 605, /* ExistingIndex */ - YYSYMBOL_ConstraintAttr = 606, /* ConstraintAttr */ - YYSYMBOL_OptWith = 607, /* OptWith */ - YYSYMBOL_definition = 608, /* definition */ - YYSYMBOL_TableLikeOptionList = 609, /* TableLikeOptionList */ - YYSYMBOL_generic_option_name = 610, /* generic_option_name */ - YYSYMBOL_ConstraintAttributeElem = 611, /* ConstraintAttributeElem */ - YYSYMBOL_columnDef = 612, /* columnDef */ - YYSYMBOL_def_list = 613, /* def_list */ - YYSYMBOL_index_name = 614, /* index_name */ - YYSYMBOL_TableElement = 615, /* TableElement */ - YYSYMBOL_def_elem = 616, /* def_elem */ - YYSYMBOL_opt_definition = 617, /* opt_definition */ - YYSYMBOL_OptTableElementList = 618, /* OptTableElementList */ - YYSYMBOL_columnElem = 619, /* columnElem */ - YYSYMBOL_opt_column_list = 620, /* opt_column_list */ - YYSYMBOL_ColQualList = 621, /* ColQualList */ - YYSYMBOL_key_delete = 622, /* key_delete */ - YYSYMBOL_reloption_elem = 623, /* reloption_elem */ - YYSYMBOL_columnList = 624, /* columnList */ - YYSYMBOL_columnList_opt_comma = 625, /* columnList_opt_comma */ - YYSYMBOL_func_type = 626, /* func_type */ - YYSYMBOL_ConstraintElem = 627, /* ConstraintElem */ - YYSYMBOL_TableElementList = 628, /* TableElementList */ - YYSYMBOL_key_match = 629, /* key_match */ - YYSYMBOL_TableLikeClause = 630, /* TableLikeClause */ - YYSYMBOL_OptTemp = 631, /* OptTemp */ - YYSYMBOL_generated_when = 632, /* generated_when */ - YYSYMBOL_CreateAsStmt = 633, /* CreateAsStmt */ - YYSYMBOL_opt_with_data = 634, /* opt_with_data */ - YYSYMBOL_create_as_target = 635, /* create_as_target */ - YYSYMBOL_unreserved_keyword = 636, /* unreserved_keyword */ - YYSYMBOL_col_name_keyword = 637, /* col_name_keyword */ - YYSYMBOL_func_name_keyword = 638, /* func_name_keyword */ - YYSYMBOL_type_name_keyword = 639, /* type_name_keyword */ - YYSYMBOL_other_keyword = 640, /* other_keyword */ - YYSYMBOL_type_func_name_keyword = 641, /* type_func_name_keyword */ - YYSYMBOL_reserved_keyword = 642, /* reserved_keyword */ - YYSYMBOL_CreateFunctionStmt = 643, /* CreateFunctionStmt */ - YYSYMBOL_macro_alias = 644, /* macro_alias */ - YYSYMBOL_param_list = 645, /* param_list */ - YYSYMBOL_CreateSchemaStmt = 646, /* CreateSchemaStmt */ - YYSYMBOL_OptSchemaEltList = 647, /* OptSchemaEltList */ - YYSYMBOL_schema_stmt = 648, /* schema_stmt */ - YYSYMBOL_CreateSecretStmt = 649, /* CreateSecretStmt */ - YYSYMBOL_opt_secret_name = 650, /* opt_secret_name */ - YYSYMBOL_opt_persist = 651, /* opt_persist */ - YYSYMBOL_opt_storage_specifier = 652, /* opt_storage_specifier */ - YYSYMBOL_CreateSeqStmt = 653, /* CreateSeqStmt */ - YYSYMBOL_OptSeqOptList = 654, /* OptSeqOptList */ - YYSYMBOL_CreateTypeStmt = 655, /* CreateTypeStmt */ - YYSYMBOL_opt_enum_val_list = 656, /* opt_enum_val_list */ - YYSYMBOL_enum_val_list = 657, /* enum_val_list */ - YYSYMBOL_DeallocateStmt = 658, /* DeallocateStmt */ - YYSYMBOL_DeleteStmt = 659, /* DeleteStmt */ - YYSYMBOL_relation_expr_opt_alias = 660, /* relation_expr_opt_alias */ - YYSYMBOL_where_or_current_clause = 661, /* where_or_current_clause */ - YYSYMBOL_using_clause = 662, /* using_clause */ - YYSYMBOL_DropStmt = 663, /* DropStmt */ - YYSYMBOL_drop_type_any_name = 664, /* drop_type_any_name */ - YYSYMBOL_drop_type_name = 665, /* drop_type_name */ - YYSYMBOL_any_name_list = 666, /* any_name_list */ - YYSYMBOL_opt_drop_behavior = 667, /* opt_drop_behavior */ - YYSYMBOL_drop_type_name_on_any_name = 668, /* drop_type_name_on_any_name */ - YYSYMBOL_DropSecretStmt = 669, /* DropSecretStmt */ - YYSYMBOL_opt_storage_drop_specifier = 670, /* opt_storage_drop_specifier */ - YYSYMBOL_ExecuteStmt = 671, /* ExecuteStmt */ - YYSYMBOL_execute_param_expr = 672, /* execute_param_expr */ - YYSYMBOL_execute_param_list = 673, /* execute_param_list */ - YYSYMBOL_execute_param_clause = 674, /* execute_param_clause */ - YYSYMBOL_ExplainStmt = 675, /* ExplainStmt */ - YYSYMBOL_opt_verbose = 676, /* opt_verbose */ - YYSYMBOL_explain_option_arg = 677, /* explain_option_arg */ - YYSYMBOL_ExplainableStmt = 678, /* ExplainableStmt */ - YYSYMBOL_NonReservedWord = 679, /* NonReservedWord */ - YYSYMBOL_NonReservedWord_or_Sconst = 680, /* NonReservedWord_or_Sconst */ - YYSYMBOL_explain_option_list = 681, /* explain_option_list */ - YYSYMBOL_analyze_keyword = 682, /* analyze_keyword */ - YYSYMBOL_opt_boolean_or_string = 683, /* opt_boolean_or_string */ - YYSYMBOL_explain_option_elem = 684, /* explain_option_elem */ - YYSYMBOL_explain_option_name = 685, /* explain_option_name */ - YYSYMBOL_ExportStmt = 686, /* ExportStmt */ - YYSYMBOL_ImportStmt = 687, /* ImportStmt */ - YYSYMBOL_IndexStmt = 688, /* IndexStmt */ - YYSYMBOL_access_method = 689, /* access_method */ - YYSYMBOL_access_method_clause = 690, /* access_method_clause */ - YYSYMBOL_opt_concurrently = 691, /* opt_concurrently */ - YYSYMBOL_opt_index_name = 692, /* opt_index_name */ - YYSYMBOL_opt_reloptions = 693, /* opt_reloptions */ - YYSYMBOL_opt_unique = 694, /* opt_unique */ - YYSYMBOL_InsertStmt = 695, /* InsertStmt */ - YYSYMBOL_insert_rest = 696, /* insert_rest */ - YYSYMBOL_insert_target = 697, /* insert_target */ - YYSYMBOL_opt_by_name_or_position = 698, /* opt_by_name_or_position */ - YYSYMBOL_opt_conf_expr = 699, /* opt_conf_expr */ - YYSYMBOL_opt_with_clause = 700, /* opt_with_clause */ - YYSYMBOL_insert_column_item = 701, /* insert_column_item */ - YYSYMBOL_set_clause = 702, /* set_clause */ - YYSYMBOL_opt_or_action = 703, /* opt_or_action */ - YYSYMBOL_opt_on_conflict = 704, /* opt_on_conflict */ - YYSYMBOL_index_elem = 705, /* index_elem */ - YYSYMBOL_returning_clause = 706, /* returning_clause */ - YYSYMBOL_override_kind = 707, /* override_kind */ - YYSYMBOL_set_target_list = 708, /* set_target_list */ - YYSYMBOL_opt_collate = 709, /* opt_collate */ - YYSYMBOL_opt_class = 710, /* opt_class */ - YYSYMBOL_insert_column_list = 711, /* insert_column_list */ - YYSYMBOL_set_clause_list = 712, /* set_clause_list */ - YYSYMBOL_set_clause_list_opt_comma = 713, /* set_clause_list_opt_comma */ - YYSYMBOL_index_params = 714, /* index_params */ - YYSYMBOL_set_target = 715, /* set_target */ - YYSYMBOL_LoadStmt = 716, /* LoadStmt */ - YYSYMBOL_file_name = 717, /* file_name */ - YYSYMBOL_repo_path = 718, /* repo_path */ - YYSYMBOL_PragmaStmt = 719, /* PragmaStmt */ - YYSYMBOL_PrepareStmt = 720, /* PrepareStmt */ - YYSYMBOL_prep_type_clause = 721, /* prep_type_clause */ - YYSYMBOL_PreparableStmt = 722, /* PreparableStmt */ - YYSYMBOL_RenameStmt = 723, /* RenameStmt */ - YYSYMBOL_opt_column = 724, /* opt_column */ - YYSYMBOL_SelectStmt = 725, /* SelectStmt */ - YYSYMBOL_select_with_parens = 726, /* select_with_parens */ - YYSYMBOL_select_no_parens = 727, /* select_no_parens */ - YYSYMBOL_select_clause = 728, /* select_clause */ - YYSYMBOL_opt_select = 729, /* opt_select */ - YYSYMBOL_simple_select = 730, /* simple_select */ - YYSYMBOL_value_or_values = 731, /* value_or_values */ - YYSYMBOL_pivot_keyword = 732, /* pivot_keyword */ - YYSYMBOL_unpivot_keyword = 733, /* unpivot_keyword */ - YYSYMBOL_pivot_column_entry = 734, /* pivot_column_entry */ - YYSYMBOL_pivot_column_list_internal = 735, /* pivot_column_list_internal */ - YYSYMBOL_pivot_column_list = 736, /* pivot_column_list */ - YYSYMBOL_with_clause = 737, /* with_clause */ - YYSYMBOL_cte_list = 738, /* cte_list */ - YYSYMBOL_common_table_expr = 739, /* common_table_expr */ - YYSYMBOL_opt_materialized = 740, /* opt_materialized */ - YYSYMBOL_into_clause = 741, /* into_clause */ - YYSYMBOL_OptTempTableName = 742, /* OptTempTableName */ - YYSYMBOL_opt_table = 743, /* opt_table */ - YYSYMBOL_all_or_distinct = 744, /* all_or_distinct */ - YYSYMBOL_by_name = 745, /* by_name */ - YYSYMBOL_distinct_clause = 746, /* distinct_clause */ - YYSYMBOL_opt_all_clause = 747, /* opt_all_clause */ - YYSYMBOL_opt_ignore_nulls = 748, /* opt_ignore_nulls */ - YYSYMBOL_opt_sort_clause = 749, /* opt_sort_clause */ - YYSYMBOL_sort_clause = 750, /* sort_clause */ - YYSYMBOL_sortby_list = 751, /* sortby_list */ - YYSYMBOL_sortby = 752, /* sortby */ - YYSYMBOL_opt_asc_desc = 753, /* opt_asc_desc */ - YYSYMBOL_opt_nulls_order = 754, /* opt_nulls_order */ - YYSYMBOL_select_limit = 755, /* select_limit */ - YYSYMBOL_opt_select_limit = 756, /* opt_select_limit */ - YYSYMBOL_limit_clause = 757, /* limit_clause */ - YYSYMBOL_offset_clause = 758, /* offset_clause */ - YYSYMBOL_sample_count = 759, /* sample_count */ - YYSYMBOL_sample_clause = 760, /* sample_clause */ - YYSYMBOL_opt_sample_func = 761, /* opt_sample_func */ - YYSYMBOL_tablesample_entry = 762, /* tablesample_entry */ - YYSYMBOL_tablesample_clause = 763, /* tablesample_clause */ - YYSYMBOL_opt_tablesample_clause = 764, /* opt_tablesample_clause */ - YYSYMBOL_opt_repeatable_clause = 765, /* opt_repeatable_clause */ - YYSYMBOL_select_limit_value = 766, /* select_limit_value */ - YYSYMBOL_select_offset_value = 767, /* select_offset_value */ - YYSYMBOL_select_fetch_first_value = 768, /* select_fetch_first_value */ - YYSYMBOL_I_or_F_const = 769, /* I_or_F_const */ - YYSYMBOL_row_or_rows = 770, /* row_or_rows */ - YYSYMBOL_first_or_next = 771, /* first_or_next */ - YYSYMBOL_group_clause = 772, /* group_clause */ - YYSYMBOL_group_by_list = 773, /* group_by_list */ - YYSYMBOL_group_by_list_opt_comma = 774, /* group_by_list_opt_comma */ - YYSYMBOL_group_by_item = 775, /* group_by_item */ - YYSYMBOL_empty_grouping_set = 776, /* empty_grouping_set */ - YYSYMBOL_rollup_clause = 777, /* rollup_clause */ - YYSYMBOL_cube_clause = 778, /* cube_clause */ - YYSYMBOL_grouping_sets_clause = 779, /* grouping_sets_clause */ - YYSYMBOL_grouping_or_grouping_id = 780, /* grouping_or_grouping_id */ - YYSYMBOL_having_clause = 781, /* having_clause */ - YYSYMBOL_qualify_clause = 782, /* qualify_clause */ - YYSYMBOL_for_locking_clause = 783, /* for_locking_clause */ - YYSYMBOL_opt_for_locking_clause = 784, /* opt_for_locking_clause */ - YYSYMBOL_for_locking_items = 785, /* for_locking_items */ - YYSYMBOL_for_locking_item = 786, /* for_locking_item */ - YYSYMBOL_for_locking_strength = 787, /* for_locking_strength */ - YYSYMBOL_locked_rels_list = 788, /* locked_rels_list */ - YYSYMBOL_opt_nowait_or_skip = 789, /* opt_nowait_or_skip */ - YYSYMBOL_values_clause = 790, /* values_clause */ - YYSYMBOL_values_clause_opt_comma = 791, /* values_clause_opt_comma */ - YYSYMBOL_from_clause = 792, /* from_clause */ - YYSYMBOL_from_list = 793, /* from_list */ - YYSYMBOL_from_list_opt_comma = 794, /* from_list_opt_comma */ - YYSYMBOL_table_ref = 795, /* table_ref */ - YYSYMBOL_opt_pivot_group_by = 796, /* opt_pivot_group_by */ - YYSYMBOL_opt_include_nulls = 797, /* opt_include_nulls */ - YYSYMBOL_single_pivot_value = 798, /* single_pivot_value */ - YYSYMBOL_pivot_header = 799, /* pivot_header */ - YYSYMBOL_pivot_value = 800, /* pivot_value */ - YYSYMBOL_pivot_value_list = 801, /* pivot_value_list */ - YYSYMBOL_unpivot_header = 802, /* unpivot_header */ - YYSYMBOL_unpivot_value = 803, /* unpivot_value */ - YYSYMBOL_unpivot_value_list = 804, /* unpivot_value_list */ - YYSYMBOL_joined_table = 805, /* joined_table */ - YYSYMBOL_alias_clause = 806, /* alias_clause */ - YYSYMBOL_opt_alias_clause = 807, /* opt_alias_clause */ - YYSYMBOL_func_alias_clause = 808, /* func_alias_clause */ - YYSYMBOL_join_type = 809, /* join_type */ - YYSYMBOL_join_outer = 810, /* join_outer */ - YYSYMBOL_join_qual = 811, /* join_qual */ - YYSYMBOL_relation_expr = 812, /* relation_expr */ - YYSYMBOL_func_table = 813, /* func_table */ - YYSYMBOL_rowsfrom_item = 814, /* rowsfrom_item */ - YYSYMBOL_rowsfrom_list = 815, /* rowsfrom_list */ - YYSYMBOL_opt_col_def_list = 816, /* opt_col_def_list */ - YYSYMBOL_opt_ordinality = 817, /* opt_ordinality */ - YYSYMBOL_where_clause = 818, /* where_clause */ - YYSYMBOL_TableFuncElementList = 819, /* TableFuncElementList */ - YYSYMBOL_TableFuncElement = 820, /* TableFuncElement */ - YYSYMBOL_opt_collate_clause = 821, /* opt_collate_clause */ - YYSYMBOL_colid_type_list = 822, /* colid_type_list */ - YYSYMBOL_RowOrStruct = 823, /* RowOrStruct */ - YYSYMBOL_opt_Typename = 824, /* opt_Typename */ - YYSYMBOL_Typename = 825, /* Typename */ - YYSYMBOL_qualified_typename = 826, /* qualified_typename */ - YYSYMBOL_opt_array_bounds = 827, /* opt_array_bounds */ - YYSYMBOL_SimpleTypename = 828, /* SimpleTypename */ - YYSYMBOL_ConstTypename = 829, /* ConstTypename */ - YYSYMBOL_GenericType = 830, /* GenericType */ - YYSYMBOL_opt_type_modifiers = 831, /* opt_type_modifiers */ - YYSYMBOL_Numeric = 832, /* Numeric */ - YYSYMBOL_opt_float = 833, /* opt_float */ - YYSYMBOL_Bit = 834, /* Bit */ - YYSYMBOL_ConstBit = 835, /* ConstBit */ - YYSYMBOL_BitWithLength = 836, /* BitWithLength */ - YYSYMBOL_BitWithoutLength = 837, /* BitWithoutLength */ - YYSYMBOL_Character = 838, /* Character */ - YYSYMBOL_ConstCharacter = 839, /* ConstCharacter */ - YYSYMBOL_CharacterWithLength = 840, /* CharacterWithLength */ - YYSYMBOL_CharacterWithoutLength = 841, /* CharacterWithoutLength */ - YYSYMBOL_character = 842, /* character */ - YYSYMBOL_opt_varying = 843, /* opt_varying */ - YYSYMBOL_ConstDatetime = 844, /* ConstDatetime */ - YYSYMBOL_ConstInterval = 845, /* ConstInterval */ - YYSYMBOL_opt_timezone = 846, /* opt_timezone */ - YYSYMBOL_year_keyword = 847, /* year_keyword */ - YYSYMBOL_month_keyword = 848, /* month_keyword */ - YYSYMBOL_day_keyword = 849, /* day_keyword */ - YYSYMBOL_hour_keyword = 850, /* hour_keyword */ - YYSYMBOL_minute_keyword = 851, /* minute_keyword */ - YYSYMBOL_second_keyword = 852, /* second_keyword */ - YYSYMBOL_millisecond_keyword = 853, /* millisecond_keyword */ - YYSYMBOL_microsecond_keyword = 854, /* microsecond_keyword */ - YYSYMBOL_week_keyword = 855, /* week_keyword */ - YYSYMBOL_decade_keyword = 856, /* decade_keyword */ - YYSYMBOL_century_keyword = 857, /* century_keyword */ - YYSYMBOL_millennium_keyword = 858, /* millennium_keyword */ - YYSYMBOL_opt_interval = 859, /* opt_interval */ - YYSYMBOL_a_expr = 860, /* a_expr */ - YYSYMBOL_b_expr = 861, /* b_expr */ - YYSYMBOL_c_expr = 862, /* c_expr */ - YYSYMBOL_d_expr = 863, /* d_expr */ - YYSYMBOL_indirection_expr = 864, /* indirection_expr */ - YYSYMBOL_struct_expr = 865, /* struct_expr */ - YYSYMBOL_func_application = 866, /* func_application */ - YYSYMBOL_func_expr = 867, /* func_expr */ - YYSYMBOL_func_expr_windowless = 868, /* func_expr_windowless */ - YYSYMBOL_func_expr_common_subexpr = 869, /* func_expr_common_subexpr */ - YYSYMBOL_list_comprehension = 870, /* list_comprehension */ - YYSYMBOL_within_group_clause = 871, /* within_group_clause */ - YYSYMBOL_filter_clause = 872, /* filter_clause */ - YYSYMBOL_export_clause = 873, /* export_clause */ - YYSYMBOL_window_clause = 874, /* window_clause */ - YYSYMBOL_window_definition_list = 875, /* window_definition_list */ - YYSYMBOL_window_definition = 876, /* window_definition */ - YYSYMBOL_over_clause = 877, /* over_clause */ - YYSYMBOL_window_specification = 878, /* window_specification */ - YYSYMBOL_opt_existing_window_name = 879, /* opt_existing_window_name */ - YYSYMBOL_opt_partition_clause = 880, /* opt_partition_clause */ - YYSYMBOL_opt_frame_clause = 881, /* opt_frame_clause */ - YYSYMBOL_frame_extent = 882, /* frame_extent */ - YYSYMBOL_frame_bound = 883, /* frame_bound */ - YYSYMBOL_opt_window_exclusion_clause = 884, /* opt_window_exclusion_clause */ - YYSYMBOL_qualified_row = 885, /* qualified_row */ - YYSYMBOL_row = 886, /* row */ - YYSYMBOL_dict_arg = 887, /* dict_arg */ - YYSYMBOL_dict_arguments = 888, /* dict_arguments */ - YYSYMBOL_dict_arguments_opt_comma = 889, /* dict_arguments_opt_comma */ - YYSYMBOL_map_arg = 890, /* map_arg */ - YYSYMBOL_map_arguments = 891, /* map_arguments */ - YYSYMBOL_map_arguments_opt_comma = 892, /* map_arguments_opt_comma */ - YYSYMBOL_opt_map_arguments_opt_comma = 893, /* opt_map_arguments_opt_comma */ - YYSYMBOL_sub_type = 894, /* sub_type */ - YYSYMBOL_all_Op = 895, /* all_Op */ - YYSYMBOL_MathOp = 896, /* MathOp */ - YYSYMBOL_qual_Op = 897, /* qual_Op */ - YYSYMBOL_qual_all_Op = 898, /* qual_all_Op */ - YYSYMBOL_subquery_Op = 899, /* subquery_Op */ - YYSYMBOL_any_operator = 900, /* any_operator */ - YYSYMBOL_c_expr_list = 901, /* c_expr_list */ - YYSYMBOL_c_expr_list_opt_comma = 902, /* c_expr_list_opt_comma */ - YYSYMBOL_expr_list = 903, /* expr_list */ - YYSYMBOL_expr_list_opt_comma = 904, /* expr_list_opt_comma */ - YYSYMBOL_opt_expr_list_opt_comma = 905, /* opt_expr_list_opt_comma */ - YYSYMBOL_func_arg_list = 906, /* func_arg_list */ - YYSYMBOL_func_arg_expr = 907, /* func_arg_expr */ - YYSYMBOL_type_list = 908, /* type_list */ - YYSYMBOL_extract_list = 909, /* extract_list */ - YYSYMBOL_extract_arg = 910, /* extract_arg */ - YYSYMBOL_overlay_list = 911, /* overlay_list */ - YYSYMBOL_overlay_placing = 912, /* overlay_placing */ - YYSYMBOL_position_list = 913, /* position_list */ - YYSYMBOL_substr_list = 914, /* substr_list */ - YYSYMBOL_substr_from = 915, /* substr_from */ - YYSYMBOL_substr_for = 916, /* substr_for */ - YYSYMBOL_trim_list = 917, /* trim_list */ - YYSYMBOL_in_expr = 918, /* in_expr */ - YYSYMBOL_case_expr = 919, /* case_expr */ - YYSYMBOL_when_clause_list = 920, /* when_clause_list */ - YYSYMBOL_when_clause = 921, /* when_clause */ - YYSYMBOL_case_default = 922, /* case_default */ - YYSYMBOL_case_arg = 923, /* case_arg */ - YYSYMBOL_columnref = 924, /* columnref */ - YYSYMBOL_opt_slice_bound = 925, /* opt_slice_bound */ - YYSYMBOL_opt_indirection = 926, /* opt_indirection */ - YYSYMBOL_opt_func_arguments = 927, /* opt_func_arguments */ - YYSYMBOL_extended_indirection_el = 928, /* extended_indirection_el */ - YYSYMBOL_opt_extended_indirection = 929, /* opt_extended_indirection */ - YYSYMBOL_opt_asymmetric = 930, /* opt_asymmetric */ - YYSYMBOL_opt_target_list_opt_comma = 931, /* opt_target_list_opt_comma */ - YYSYMBOL_target_list = 932, /* target_list */ - YYSYMBOL_target_list_opt_comma = 933, /* target_list_opt_comma */ - YYSYMBOL_target_el = 934, /* target_el */ - YYSYMBOL_except_list = 935, /* except_list */ - YYSYMBOL_opt_except_list = 936, /* opt_except_list */ - YYSYMBOL_replace_list_el = 937, /* replace_list_el */ - YYSYMBOL_replace_list = 938, /* replace_list */ - YYSYMBOL_replace_list_opt_comma = 939, /* replace_list_opt_comma */ - YYSYMBOL_opt_replace_list = 940, /* opt_replace_list */ - YYSYMBOL_qualified_name_list = 941, /* qualified_name_list */ - YYSYMBOL_name_list = 942, /* name_list */ - YYSYMBOL_name_list_opt_comma = 943, /* name_list_opt_comma */ - YYSYMBOL_name_list_opt_comma_opt_bracket = 944, /* name_list_opt_comma_opt_bracket */ - YYSYMBOL_name = 945, /* name */ - YYSYMBOL_func_name = 946, /* func_name */ - YYSYMBOL_AexprConst = 947, /* AexprConst */ - YYSYMBOL_Iconst = 948, /* Iconst */ - YYSYMBOL_type_function_name = 949, /* type_function_name */ - YYSYMBOL_function_name_token = 950, /* function_name_token */ - YYSYMBOL_type_name_token = 951, /* type_name_token */ - YYSYMBOL_any_name = 952, /* any_name */ - YYSYMBOL_attrs = 953, /* attrs */ - YYSYMBOL_opt_name_list = 954, /* opt_name_list */ - YYSYMBOL_param_name = 955, /* param_name */ - YYSYMBOL_ColLabelOrString = 956, /* ColLabelOrString */ - YYSYMBOL_TransactionStmt = 957, /* TransactionStmt */ - YYSYMBOL_opt_transaction = 958, /* opt_transaction */ - YYSYMBOL_UpdateStmt = 959, /* UpdateStmt */ - YYSYMBOL_UseStmt = 960, /* UseStmt */ - YYSYMBOL_VacuumStmt = 961, /* VacuumStmt */ - YYSYMBOL_vacuum_option_elem = 962, /* vacuum_option_elem */ - YYSYMBOL_opt_full = 963, /* opt_full */ - YYSYMBOL_vacuum_option_list = 964, /* vacuum_option_list */ - YYSYMBOL_opt_freeze = 965, /* opt_freeze */ - YYSYMBOL_VariableResetStmt = 966, /* VariableResetStmt */ - YYSYMBOL_generic_reset = 967, /* generic_reset */ - YYSYMBOL_reset_rest = 968, /* reset_rest */ - YYSYMBOL_VariableSetStmt = 969, /* VariableSetStmt */ - YYSYMBOL_set_rest = 970, /* set_rest */ - YYSYMBOL_generic_set = 971, /* generic_set */ - YYSYMBOL_var_value = 972, /* var_value */ - YYSYMBOL_zone_value = 973, /* zone_value */ - YYSYMBOL_var_list = 974, /* var_list */ - YYSYMBOL_VariableShowStmt = 975, /* VariableShowStmt */ - YYSYMBOL_describe_or_desc = 976, /* describe_or_desc */ - YYSYMBOL_show_or_describe = 977, /* show_or_describe */ - YYSYMBOL_opt_tables = 978, /* opt_tables */ - YYSYMBOL_var_name = 979, /* var_name */ - YYSYMBOL_table_id = 980, /* table_id */ - YYSYMBOL_ViewStmt = 981, /* ViewStmt */ - YYSYMBOL_opt_check_option = 982 /* opt_check_option */ -}; -typedef enum yysymbol_kind_t yysymbol_kind_t; +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +#line 14 "third_party/libpg_query/grammar/grammar.y" +{ + core_YYSTYPE core_yystype; + /* these fields must match core_YYSTYPE: */ + int ival; + char *str; + const char *keyword; + const char *conststr; + char chr; + bool boolean; + PGJoinType jtype; + PGDropBehavior dbehavior; + PGOnCommitAction oncommit; + PGOnCreateConflict oncreateconflict; + PGList *list; + PGNode *node; + PGValue *value; + PGObjectType objtype; + PGTypeName *typnam; + PGObjectWithArgs *objwithargs; + PGDefElem *defelt; + PGSortBy *sortby; + PGWindowDef *windef; + PGJoinExpr *jexpr; + PGIndexElem *ielem; + PGAlias *alias; + PGRangeVar *range; + PGIntoClause *into; + PGCTEMaterialize ctematerialize; + PGWithClause *with; + PGInferClause *infer; + PGOnConflictClause *onconflict; + PGOnConflictActionAlias onconflictshorthand; + PGAIndices *aind; + PGResTarget *target; + PGInsertStmt *istmt; + PGVariableSetStmt *vsetstmt; + PGOverridingKind override; + PGSortByDir sortorder; + PGSortByNulls nullorder; + PGConstrType constr; + PGLockClauseStrength lockstrength; + PGLockWaitPolicy lockwaitpolicy; + PGSubLinkType subquerytype; + PGViewCheckOption viewcheckoption; + PGInsertColumnOrder bynameorposition; +} +/* Line 193 of yacc.c. */ +#line 1321 "third_party/libpg_query/grammar/grammar_out.cpp" + YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif -#ifdef short -# undef short +#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED +typedef struct YYLTYPE +{ + int first_line; + int first_column; + int last_line; + int last_column; +} YYLTYPE; +# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ +# define YYLTYPE_IS_DECLARED 1 +# define YYLTYPE_IS_TRIVIAL 1 #endif -/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure - and (if available) are included - so that the code can choose integer types of a good width. */ -#ifndef __PTRDIFF_MAX__ -# include /* INFRINGES ON USER NAME SPACE */ -# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ -# include /* INFRINGES ON USER NAME SPACE */ -# define YY_STDINT_H -# endif -#endif +/* Copy the second part of user declarations. */ -/* Narrow types that promote to a signed type and that can represent a - signed or unsigned integer of at least N bits. In tables they can - save space and decrease cache pressure. Promoting to a signed type - helps avoid bugs in integer arithmetic. */ -#ifdef __INT_LEAST8_MAX__ -typedef __INT_LEAST8_TYPE__ yytype_int8; -#elif defined YY_STDINT_H -typedef int_least8_t yytype_int8; -#else -typedef signed char yytype_int8; +/* Line 216 of yacc.c. */ +#line 1346 "third_party/libpg_query/grammar/grammar_out.cpp" + +#ifdef short +# undef short #endif -#ifdef __INT_LEAST16_MAX__ -typedef __INT_LEAST16_TYPE__ yytype_int16; -#elif defined YY_STDINT_H -typedef int_least16_t yytype_int16; +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; #else -typedef short yytype_int16; -#endif - -/* Work around bug in HP-UX 11.23, which defines these macros - incorrectly for preprocessor constants. This workaround can likely - be removed in 2023, as HPE has promised support for HP-UX 11.23 - (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of - . */ -#ifdef __hpux -# undef UINT_LEAST8_MAX -# undef UINT_LEAST16_MAX -# define UINT_LEAST8_MAX 255 -# define UINT_LEAST16_MAX 65535 -#endif - -#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ -typedef __UINT_LEAST8_TYPE__ yytype_uint8; -#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ - && UINT_LEAST8_MAX <= INT_MAX) -typedef uint_least8_t yytype_uint8; -#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#elif (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +typedef signed char yytype_int8; #else -typedef short yytype_uint8; +typedef short int yytype_int8; #endif -#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ -typedef __UINT_LEAST16_TYPE__ yytype_uint16; -#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ - && UINT_LEAST16_MAX <= INT_MAX) -typedef uint_least16_t yytype_uint16; -#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX -typedef unsigned short yytype_uint16; +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; #else -typedef int yytype_uint16; +typedef unsigned short int yytype_uint16; #endif -#ifndef YYPTRDIFF_T -# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ -# define YYPTRDIFF_T __PTRDIFF_TYPE__ -# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ -# elif defined PTRDIFF_MAX -# ifndef ptrdiff_t -# include /* INFRINGES ON USER NAME SPACE */ -# endif -# define YYPTRDIFF_T ptrdiff_t -# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX -# else -# define YYPTRDIFF_T long -# define YYPTRDIFF_MAXIMUM LONG_MAX -# endif +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; #endif #ifndef YYSIZE_T @@ -387862,106 +391313,55 @@ typedef int yytype_uint16; # define YYSIZE_T __SIZE_TYPE__ # elif defined size_t # define YYSIZE_T size_t -# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else -# define YYSIZE_T unsigned +# define YYSIZE_T unsigned int # endif #endif -#define YYSIZE_MAXIMUM \ - YY_CAST (YYPTRDIFF_T, \ - (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ - ? YYPTRDIFF_MAXIMUM \ - : YY_CAST (YYSIZE_T, -1))) - -#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) - - -/* Stored state numbers (used for stacks). */ -typedef yytype_int16 yy_state_t; - -/* State numbers in computations. */ -typedef int yy_state_fast_t; +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) #ifndef YY_ # if defined YYENABLE_NLS && YYENABLE_NLS # if ENABLE_NLS # include /* INFRINGES ON USER NAME SPACE */ -# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# define YY_(msgid) dgettext ("bison-runtime", msgid) # endif # endif # ifndef YY_ -# define YY_(Msgid) Msgid -# endif -#endif - - -#ifndef YY_ATTRIBUTE_PURE -# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) -# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) -# else -# define YY_ATTRIBUTE_PURE -# endif -#endif - -#ifndef YY_ATTRIBUTE_UNUSED -# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) -# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) -# else -# define YY_ATTRIBUTE_UNUSED +# define YY_(msgid) msgid # endif #endif /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ -# define YY_USE(E) ((void) (E)) +# define YYUSE(e) ((void) (e)) #else -# define YY_USE(E) /* empty */ +# define YYUSE(e) /* empty */ #endif -/* Suppress an incorrect diagnostic about yylval being uninitialized. */ -#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ -# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") -# else -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ - _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") -# endif -# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ - _Pragma ("GCC diagnostic pop") +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(n) (n) #else -# define YY_INITIAL_VALUE(Value) Value -#endif -#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN -# define YY_IGNORE_MAYBE_UNINITIALIZED_END -#endif -#ifndef YY_INITIAL_VALUE -# define YY_INITIAL_VALUE(Value) /* Nothing. */ -#endif - -#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ -# define YY_IGNORE_USELESS_CAST_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") -# define YY_IGNORE_USELESS_CAST_END \ - _Pragma ("GCC diagnostic pop") +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID (int i) +#else +static int +YYID (i) + int i; #endif -#ifndef YY_IGNORE_USELESS_CAST_BEGIN -# define YY_IGNORE_USELESS_CAST_BEGIN -# define YY_IGNORE_USELESS_CAST_END +{ + return i; +} #endif - -#define YY_ASSERT(E) ((void) (0 && (E))) - -#if !defined yyoverflow +#if ! defined yyoverflow || YYERROR_VERBOSE /* The parser invokes alloca or malloc; define the necessary symbols. */ @@ -387978,11 +391378,11 @@ typedef int yy_state_fast_t; # define alloca _alloca # else # define YYSTACK_ALLOC alloca -# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS +# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) # include /* INFRINGES ON USER NAME SPACE */ - /* Use EXIT_SUCCESS as a witness for stdlib.h. */ -# ifndef EXIT_SUCCESS -# define EXIT_SUCCESS 0 +# ifndef _STDLIB_H +# define _STDLIB_H 1 # endif # endif # endif @@ -387990,8 +391390,8 @@ typedef int yy_state_fast_t; # endif # ifdef YYSTACK_ALLOC - /* Pacify GCC's 'empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) # ifndef YYSTACK_ALLOC_MAXIMUM /* The OS might guarantee only one guard page at the bottom of the stack, and a page size can be as small as 4096 bytes. So we cannot safely @@ -388005,134 +391405,127 @@ typedef int yy_state_fast_t; # ifndef YYSTACK_ALLOC_MAXIMUM # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM # endif -# if (defined __cplusplus && ! defined EXIT_SUCCESS \ +# if (defined __cplusplus && ! defined _STDLIB_H \ && ! ((defined YYMALLOC || defined malloc) \ - && (defined YYFREE || defined free))) + && (defined YYFREE || defined free))) # include /* INFRINGES ON USER NAME SPACE */ -# ifndef EXIT_SUCCESS -# define EXIT_SUCCESS 0 +# ifndef _STDLIB_H +# define _STDLIB_H 1 # endif # endif # ifndef YYMALLOC # define YYMALLOC malloc -# if ! defined malloc && ! defined EXIT_SUCCESS +# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ # endif # endif # ifndef YYFREE # define YYFREE free -# if ! defined free && ! defined EXIT_SUCCESS +# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) void free (void *); /* INFRINGES ON USER NAME SPACE */ # endif # endif # endif -#endif /* !defined yyoverflow */ +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + #if (! defined yyoverflow \ && (! defined __cplusplus \ - || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ - && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ + && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc { - yy_state_t yyss_alloc; - YYSTYPE yyvs_alloc; - YYLTYPE yyls_alloc; + yytype_int16 yyss; + YYSTYPE yyvs; + YYLTYPE yyls; }; /* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ # define YYSTACK_BYTES(N) \ - ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \ - + YYSIZEOF (YYLTYPE)) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + 2 * YYSTACK_GAP_MAXIMUM) -# define YYCOPY_NEEDED 1 +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif /* Relocate STACK from its old location to the new one. The local variables YYSIZE and YYSTACKSIZE give the old and new number of elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack. */ -# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ - do \ - { \ - YYPTRDIFF_T yynewbytes; \ - YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ - Stack = &yyptr->Stack_alloc; \ - yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / YYSIZEOF (*yyptr); \ - } \ - while (0) +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) #endif -#if defined YYCOPY_NEEDED && YYCOPY_NEEDED -/* Copy COUNT objects from SRC to DST. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if defined __GNUC__ && 1 < __GNUC__ -# define YYCOPY(Dst, Src, Count) \ - __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) -# else -# define YYCOPY(Dst, Src, Count) \ - do \ - { \ - YYPTRDIFF_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (Dst)[yyi] = (Src)[yyi]; \ - } \ - while (0) -# endif -# endif -#endif /* !YYCOPY_NEEDED */ - /* YYFINAL -- State number of the termination state. */ #define YYFINAL 867 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 72555 +#define YYLAST 72581 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 525 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 458 +#define YYNNTS 459 /* YYNRULES -- Number of rules. */ -#define YYNRULES 2115 -/* YYNSTATES -- Number of states. */ -#define YYNSTATES 3524 +#define YYNRULES 2118 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 3526 -/* YYMAXUTOK -- Last valid token kind. */ +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 #define YYMAXUTOK 757 +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) -/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM - as returned by yylex, with out-of-bounds checking. */ -#define YYTRANSLATE(YYX) \ - (0 <= (YYX) && (YYX) <= YYMAXUTOK \ - ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ - : YYSYMBOL_YYUNDEF) - -/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM - as returned by yylex. */ -static const yytype_int16 yytranslate[] = +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint16 yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 519, 520, 509, 2, 2, + 2, 2, 2, 2, 2, 522, 523, 509, 2, 2, 514, 515, 507, 505, 518, 506, 516, 508, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 524, 517, - 501, 503, 502, 521, 2, 2, 2, 2, 2, 2, + 501, 503, 502, 519, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 512, 2, 513, 510, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 522, 2, 523, 2, 2, 2, 2, + 2, 2, 2, 520, 2, 521, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -388199,8 +391592,869 @@ static const yytype_int16 yytranslate[] = }; #if YYDEBUG -/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ -static const yytype_int16 yyrline[] = +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint16 yyprhs[] = +{ + 0, 0, 3, 5, 9, 11, 13, 15, 17, 19, + 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, + 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, + 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, + 81, 83, 85, 87, 89, 91, 92, 97, 104, 109, + 116, 121, 128, 133, 140, 142, 145, 149, 152, 154, + 158, 161, 165, 167, 171, 174, 180, 184, 191, 196, + 203, 210, 217, 223, 229, 236, 246, 251, 257, 265, + 272, 277, 286, 291, 294, 299, 303, 310, 315, 318, + 321, 324, 327, 329, 332, 333, 335, 338, 341, 344, + 346, 350, 355, 358, 360, 361, 364, 368, 371, 375, + 377, 380, 382, 384, 386, 388, 390, 392, 394, 397, + 400, 402, 404, 406, 408, 410, 417, 424, 433, 440, + 449, 456, 465, 472, 481, 490, 501, 510, 521, 523, + 524, 534, 536, 541, 546, 554, 557, 559, 563, 566, + 569, 570, 575, 579, 580, 582, 583, 586, 590, 596, + 599, 602, 603, 612, 618, 619, 625, 631, 639, 642, + 643, 645, 647, 649, 653, 656, 657, 659, 660, 662, + 666, 668, 672, 674, 677, 679, 683, 686, 693, 702, + 708, 710, 711, 713, 717, 720, 725, 731, 737, 746, + 754, 756, 757, 766, 778, 789, 790, 792, 793, 795, + 797, 798, 801, 805, 815, 828, 830, 834, 836, 840, + 844, 845, 850, 857, 859, 862, 864, 866, 867, 869, + 872, 875, 877, 880, 883, 885, 888, 892, 895, 898, + 901, 904, 908, 912, 916, 918, 922, 924, 925, 927, + 930, 933, 939, 947, 948, 951, 954, 957, 960, 963, + 966, 969, 971, 973, 974, 977, 987, 1000, 1012, 1013, + 1016, 1018, 1020, 1022, 1024, 1026, 1028, 1032, 1033, 1035, + 1038, 1040, 1042, 1045, 1048, 1052, 1054, 1056, 1059, 1062, + 1064, 1067, 1071, 1077, 1081, 1084, 1090, 1092, 1094, 1096, + 1097, 1103, 1111, 1117, 1120, 1124, 1126, 1128, 1131, 1134, + 1135, 1139, 1144, 1149, 1150, 1154, 1157, 1158, 1162, 1164, + 1166, 1168, 1170, 1172, 1174, 1176, 1178, 1180, 1182, 1186, + 1190, 1192, 1195, 1198, 1201, 1204, 1207, 1210, 1211, 1215, + 1219, 1223, 1224, 1226, 1229, 1231, 1234, 1237, 1240, 1243, + 1247, 1252, 1254, 1258, 1260, 1262, 1264, 1266, 1270, 1272, + 1275, 1276, 1278, 1281, 1282, 1284, 1288, 1289, 1292, 1293, + 1297, 1301, 1303, 1309, 1313, 1315, 1319, 1321, 1324, 1326, + 1331, 1337, 1343, 1350, 1354, 1362, 1367, 1379, 1381, 1385, + 1388, 1391, 1394, 1395, 1399, 1401, 1403, 1406, 1409, 1412, + 1415, 1417, 1418, 1420, 1423, 1430, 1435, 1442, 1447, 1454, + 1463, 1465, 1467, 1469, 1471, 1474, 1476, 1479, 1481, 1484, + 1486, 1488, 1490, 1492, 1496, 1500, 1504, 1508, 1510, 1513, + 1516, 1518, 1522, 1524, 1526, 1528, 1532, 1534, 1536, 1537, + 1539, 1541, 1543, 1552, 1564, 1575, 1583, 1594, 1604, 1606, + 1608, 1611, 1615, 1624, 1636, 1646, 1654, 1655, 1659, 1663, + 1665, 1667, 1671, 1672, 1674, 1678, 1680, 1681, 1683, 1684, + 1686, 1687, 1689, 1693, 1695, 1697, 1699, 1703, 1705, 1706, + 1709, 1712, 1713, 1716, 1717, 1719, 1720, 1722, 1724, 1726, + 1730, 1734, 1736, 1738, 1742, 1746, 1750, 1754, 1758, 1762, + 1767, 1771, 1774, 1776, 1778, 1780, 1782, 1786, 1788, 1790, + 1794, 1796, 1798, 1802, 1806, 1810, 1812, 1815, 1820, 1825, + 1828, 1832, 1838, 1844, 1846, 1848, 1852, 1853, 1865, 1877, + 1888, 1901, 1903, 1906, 1912, 1917, 1922, 1927, 1932, 1940, + 1946, 1951, 1959, 1966, 1976, 1986, 1991, 1993, 1995, 1997, + 1999, 2001, 2003, 2005, 2011, 2013, 2015, 2019, 2021, 2024, + 2027, 2030, 2034, 2036, 2040, 2048, 2050, 2053, 2054, 2057, + 2058, 2062, 2066, 2071, 2076, 2081, 2086, 2090, 2093, 2095, + 2097, 2098, 2100, 2102, 2103, 2106, 2108, 2114, 2116, 2117, + 2120, 2123, 2124, 2126, 2127, 2131, 2137, 2139, 2143, 2148, + 2152, 2154, 2156, 2157, 2160, 2163, 2164, 2167, 2170, 2172, + 2174, 2176, 2177, 2180, 2185, 2191, 2196, 2199, 2203, 2206, + 2209, 2212, 2215, 2217, 2220, 2224, 2225, 2227, 2228, 2234, + 2236, 2241, 2248, 2251, 2253, 2254, 2259, 2260, 2262, 2264, + 2267, 2270, 2273, 2275, 2277, 2280, 2283, 2285, 2287, 2289, + 2291, 2293, 2295, 2299, 2303, 2304, 2306, 2310, 2312, 2315, + 2317, 2319, 2321, 2323, 2325, 2328, 2333, 2338, 2344, 2346, + 2348, 2351, 2352, 2355, 2356, 2358, 2362, 2364, 2365, 2367, + 2370, 2374, 2377, 2382, 2385, 2389, 2392, 2393, 2395, 2398, + 2399, 2404, 2410, 2412, 2415, 2418, 2419, 2421, 2425, 2427, + 2430, 2434, 2438, 2442, 2446, 2450, 2454, 2456, 2461, 2471, + 2481, 2485, 2486, 2489, 2492, 2493, 2499, 2503, 2504, 2506, + 2508, 2512, 2518, 2522, 2524, 2527, 2529, 2533, 2539, 2541, + 2544, 2548, 2553, 2559, 2564, 2570, 2575, 2582, 2588, 2593, + 2599, 2605, 2611, 2614, 2619, 2621, 2623, 2624, 2626, 2631, + 2637, 2642, 2643, 2646, 2649, 2652, 2654, 2656, 2658, 2660, + 2661, 2666, 2669, 2671, 2674, 2677, 2682, 2685, 2692, 2695, + 2697, 2701, 2706, 2707, 2710, 2711, 2714, 2715, 2717, 2721, + 2725, 2728, 2729, 2732, 2737, 2739, 2741, 2743, 2744, 2747, + 2751, 2757, 2764, 2767, 2771, 2773, 2779, 2785, 2791, 2795, + 2799, 2803, 2808, 2809, 2811, 2813, 2815, 2817, 2819, 2822, + 2827, 2829, 2831, 2833, 2835, 2838, 2842, 2843, 2845, 2847, + 2849, 2851, 2853, 2856, 2859, 2862, 2865, 2868, 2870, 2874, + 2875, 2877, 2879, 2881, 2883, 2889, 2892, 2894, 2896, 2898, + 2900, 2905, 2907, 2910, 2913, 2915, 2919, 2923, 2926, 2928, + 2929, 2935, 2938, 2944, 2947, 2949, 2953, 2957, 2958, 2960, + 2962, 2964, 2966, 2968, 2970, 2972, 2974, 2976, 2978, 2980, + 2982, 2984, 2986, 2988, 2990, 2992, 2994, 2996, 2998, 3000, + 3002, 3004, 3006, 3008, 3010, 3012, 3014, 3016, 3018, 3020, + 3022, 3024, 3026, 3028, 3030, 3034, 3038, 3042, 3046, 3050, + 3054, 3058, 3059, 3061, 3065, 3069, 3075, 3078, 3081, 3085, + 3089, 3093, 3097, 3101, 3105, 3109, 3113, 3117, 3121, 3125, + 3129, 3133, 3137, 3141, 3144, 3147, 3151, 3155, 3158, 3161, + 3165, 3169, 3175, 3180, 3187, 3191, 3197, 3202, 3209, 3214, + 3221, 3227, 3235, 3239, 3242, 3247, 3251, 3254, 3258, 3262, + 3266, 3270, 3275, 3279, 3284, 3288, 3293, 3299, 3306, 3313, + 3321, 3328, 3336, 3343, 3351, 3355, 3360, 3365, 3372, 3374, + 3379, 3383, 3389, 3391, 3395, 3398, 3401, 3405, 3409, 3413, + 3417, 3421, 3425, 3429, 3433, 3437, 3441, 3445, 3449, 3453, + 3457, 3461, 3464, 3467, 3473, 3480, 3487, 3495, 3497, 3500, + 3502, 3504, 3506, 3509, 3512, 3517, 3521, 3523, 3525, 3527, + 3529, 3531, 3536, 3538, 3540, 3544, 3546, 3549, 3554, 3557, + 3560, 3564, 3568, 3575, 3583, 3593, 3601, 3609, 3615, 3617, + 3619, 3621, 3627, 3634, 3641, 3646, 3651, 3656, 3661, 3668, + 3674, 3680, 3686, 3691, 3698, 3703, 3711, 3721, 3727, 3728, + 3734, 3739, 3740, 3742, 3743, 3746, 3747, 3749, 3753, 3757, + 3760, 3763, 3764, 3771, 3773, 3774, 3778, 3779, 3783, 3787, + 3791, 3792, 3794, 3799, 3802, 3805, 3808, 3811, 3814, 3818, + 3821, 3824, 3828, 3829, 3834, 3838, 3840, 3846, 3850, 3852, + 3856, 3858, 3861, 3865, 3867, 3871, 3873, 3876, 3878, 3879, + 3881, 3883, 3885, 3887, 3889, 3891, 3893, 3895, 3897, 3899, + 3901, 3903, 3905, 3907, 3909, 3911, 3913, 3915, 3917, 3919, + 3924, 3926, 3931, 3933, 3938, 3940, 3943, 3945, 3948, 3950, + 3953, 3955, 3959, 3961, 3965, 3967, 3970, 3972, 3976, 3978, + 3981, 3983, 3984, 3986, 3990, 3992, 3996, 4000, 4002, 4006, + 4010, 4011, 4013, 4015, 4017, 4019, 4021, 4023, 4025, 4027, + 4029, 4031, 4033, 4035, 4037, 4039, 4044, 4048, 4051, 4055, + 4056, 4060, 4064, 4067, 4070, 4072, 4073, 4076, 4079, 4083, + 4086, 4088, 4090, 4094, 4100, 4102, 4105, 4110, 4113, 4114, + 4116, 4117, 4119, 4122, 4126, 4132, 4140, 4148, 4150, 4151, + 4152, 4155, 4156, 4159, 4163, 4167, 4171, 4177, 4185, 4193, + 4194, 4197, 4199, 4200, 4202, 4203, 4205, 4209, 4211, 4214, + 4218, 4221, 4223, 4228, 4231, 4233, 4234, 4238, 4240, 4244, + 4246, 4249, 4254, 4257, 4258, 4260, 4264, 4266, 4270, 4272, + 4275, 4277, 4281, 4283, 4285, 4288, 4290, 4292, 4295, 4297, + 4299, 4302, 4310, 4313, 4319, 4323, 4327, 4329, 4331, 4333, + 4335, 4337, 4339, 4341, 4343, 4345, 4347, 4349, 4351, 4353, + 4355, 4358, 4361, 4365, 4369, 4370, 4372, 4374, 4376, 4382, + 4386, 4387, 4389, 4391, 4393, 4395, 4397, 4399, 4404, 4412, + 4419, 4422, 4423, 4425, 4427, 4429, 4431, 4445, 4462, 4464, + 4467, 4468, 4470, 4471, 4473, 4474, 4477, 4478, 4480, 4481, + 4488, 4497, 4504, 4513, 4520, 4529, 4533, 4536, 4538, 4539, + 4546, 4553, 4555, 4557, 4559, 4561, 4563, 4565, 4568, 4570, + 4572, 4574, 4576, 4578, 4583, 4590, 4594, 4597, 4602, 4606, + 4612, 4614, 4615, 4617, 4619, 4620, 4622, 4624, 4626, 4628, + 4630, 4632, 4634, 4636, 4638, 4640, 4642, 4644, 4646, 4648, + 4650, 4652, 4654, 4656, 4658, 4660, 4662, 4664, 4666, 4668, + 4670, 4672, 4674, 4676, 4678, 4680, 4682, 4684, 4686, 4688, + 4690, 4692, 4696, 4698, 4700, 4702, 4704, 4706, 4708, 4711, + 4713, 4715, 4718, 4722, 4726, 4730, 4732, 4736, 4740, 4743, + 4747, 4751, 4753, 4755, 4757, 4761, 4767, 4769, 4771, 4773, + 4775, 4779, 4782, 4785, 4789, 4794, 4800, 4802, 4804, 4806, + 4808, 4813, 4820, 4826, 4831, 4838, 4840, 4842, 4844, 4846, + 4848, 4850, 4851, 4853, 4857, 4859, 4860, 4868, 4872, 4874, + 4877, 4881, 4884, 4885, 4888, 4889, 4892, 4897, 4903, 4912, + 4915, 4919, 4925, 4927, 4928, 4931, 4932, 4935, 4939, 4943, + 4947, 4949, 4951, 4953, 4956, 4960, 4963, 4966, 4969, 4972, + 4976, 4981, 4985, 4987, 4989, 4991, 4993, 4995, 4997, 4998, + 5000, 5004, 5006, 5010, 5013, 5023, 5036, 5048, 5061, 5076, + 5080, 5085, 5090, 5091, 5099, 5110, 5120, 5123, 5127, 5128, + 5133, 5135, 5137, 5139, 5141, 5143, 5145, 5147, 5149, 5151, + 5153, 5155, 5157, 5159, 5161, 5163, 5165, 5167, 5169, 5171, + 5173, 5175, 5177, 5179, 5181, 5183, 5185, 5187, 5189, 5191, + 5193, 5195, 5197, 5199, 5201, 5203, 5205, 5207, 5209, 5211, + 5213, 5215, 5217, 5219, 5221, 5223, 5225, 5227, 5229, 5231, + 5233, 5235, 5237, 5239, 5241, 5243, 5245, 5247, 5249, 5251, + 5253, 5255, 5257, 5259, 5261, 5263, 5265, 5267, 5269, 5271, + 5273, 5275, 5277, 5279, 5281, 5283, 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 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int16 yyrhs[] = +{ + 526, 0, -1, 527, -1, 527, 517, 528, -1, 528, + -1, 920, -1, 586, -1, 529, -1, 957, -1, 958, + -1, 971, -1, 921, -1, 923, -1, 656, -1, 974, + -1, 652, -1, 910, -1, 578, -1, 576, -1, 598, + -1, 572, -1, 540, -1, 953, -1, 959, -1, 593, + -1, 646, -1, 582, -1, 928, -1, 926, -1, 927, + -1, 913, -1, 551, -1, 945, -1, 575, -1, 907, + -1, 549, -1, 674, -1, 595, -1, 655, -1, 597, + -1, 948, -1, 962, -1, 939, -1, 965, -1, 972, + -1, -1, 32, 416, 761, 537, -1, 32, 416, 191, + 152, 761, 537, -1, 32, 202, 541, 537, -1, 32, + 202, 191, 152, 541, 537, -1, 32, 381, 541, 537, + -1, 32, 381, 191, 152, 541, 537, -1, 32, 466, + 541, 537, -1, 32, 466, 191, 152, 541, 537, -1, + 532, -1, 530, 532, -1, 386, 117, 809, -1, 137, + 117, -1, 356, -1, 356, 588, 589, -1, 386, 590, + -1, 386, 175, 645, -1, 536, -1, 533, 518, 536, + -1, 26, 625, -1, 26, 191, 274, 152, 625, -1, + 26, 82, 625, -1, 26, 82, 191, 274, 152, 625, + -1, 32, 550, 542, 531, -1, 32, 550, 542, 137, + 274, 279, -1, 32, 550, 542, 386, 274, 279, -1, + 32, 550, 542, 386, 402, 592, -1, 32, 550, 542, + 386, 613, -1, 32, 550, 542, 354, 613, -1, 32, + 550, 542, 386, 405, 542, -1, 32, 550, 542, 26, + 175, 645, 40, 190, 601, -1, 32, 550, 542, 530, + -1, 32, 550, 542, 137, 190, -1, 32, 550, 542, + 137, 190, 191, 152, -1, 137, 550, 191, 152, 542, + 650, -1, 137, 550, 542, 650, -1, 32, 550, 542, + 539, 439, 774, 770, 535, -1, 32, 550, 542, 538, + -1, 26, 615, -1, 32, 93, 895, 599, -1, 457, + 93, 895, -1, 137, 93, 191, 152, 895, 650, -1, + 137, 93, 895, 650, -1, 386, 244, -1, 386, 448, + -1, 386, 613, -1, 354, 613, -1, 538, -1, 454, + 809, -1, -1, 609, -1, 386, 609, -1, 26, 609, + -1, 137, 623, -1, 534, -1, 537, 518, 534, -1, + 293, 514, 533, 515, -1, 386, 107, -1, 386, -1, + -1, 111, 895, -1, 111, 325, 895, -1, 111, 30, + -1, 111, 325, 30, -1, 543, -1, 542, 545, -1, + 3, -1, 977, -1, 978, -1, 542, -1, 5, -1, + 5, -1, 546, -1, 545, 546, -1, 516, 547, -1, + 548, -1, 3, -1, 981, -1, 977, -1, 983, -1, + 32, 370, 895, 350, 428, 895, -1, 32, 416, 761, + 350, 428, 895, -1, 32, 416, 191, 152, 761, 350, + 428, 895, -1, 32, 381, 541, 350, 428, 895, -1, + 32, 381, 191, 152, 541, 350, 428, 895, -1, 32, + 466, 541, 350, 428, 895, -1, 32, 466, 191, 152, + 541, 350, 428, 895, -1, 32, 202, 541, 350, 428, + 895, -1, 32, 202, 191, 152, 541, 350, 428, 895, + -1, 32, 416, 761, 350, 550, 895, 428, 895, -1, + 32, 416, 191, 152, 761, 350, 550, 895, 428, 895, + -1, 32, 416, 761, 350, 93, 895, 428, 895, -1, + 32, 416, 191, 152, 761, 350, 93, 895, 428, 895, + -1, 82, -1, -1, 556, 212, 559, 219, 553, 554, + 552, 560, 562, -1, 674, -1, 303, 563, 459, 674, + -1, 514, 567, 515, 674, -1, 514, 567, 515, 303, + 563, 459, 674, -1, 117, 460, -1, 541, -1, 541, + 40, 542, -1, 59, 265, -1, 59, 320, -1, -1, + 514, 570, 515, 767, -1, 289, 93, 895, -1, -1, + 686, -1, -1, 542, 876, -1, 571, 503, 809, -1, + 514, 564, 515, 503, 809, -1, 294, 352, -1, 294, + 192, -1, -1, 289, 91, 555, 133, 451, 386, 569, + 767, -1, 289, 91, 555, 133, 275, -1, -1, 542, + 565, 566, 702, 703, -1, 818, 565, 566, 702, 703, + -1, 514, 809, 515, 565, 566, 702, 703, -1, 358, + 882, -1, -1, 453, -1, 415, -1, 571, -1, 564, + 518, 571, -1, 80, 902, -1, -1, 902, -1, -1, + 557, -1, 567, 518, 557, -1, 558, -1, 568, 518, + 558, -1, 568, -1, 568, 518, -1, 561, -1, 570, + 518, 561, -1, 542, 876, -1, 100, 439, 541, 40, + 144, 675, -1, 100, 439, 541, 40, 144, 514, 573, + 515, -1, 100, 439, 541, 40, 774, -1, 574, -1, + -1, 544, -1, 574, 518, 544, -1, 322, 542, -1, + 322, 542, 503, 944, -1, 322, 542, 514, 856, 515, + -1, 100, 644, 381, 541, 577, -1, 100, 644, 381, + 191, 274, 152, 541, 577, -1, 100, 294, 352, 644, + 381, 541, 577, -1, 587, -1, -1, 100, 580, 377, + 579, 581, 514, 673, 515, -1, 100, 580, 377, 191, + 274, 152, 579, 581, 514, 673, 515, -1, 100, 294, + 352, 580, 377, 579, 581, 514, 673, 515, -1, -1, + 542, -1, -1, 422, -1, 313, -1, -1, 198, 3, + -1, 151, 895, 585, -1, 100, 644, 416, 976, 40, + 151, 895, 585, 975, -1, 100, 644, 416, 191, 274, + 152, 976, 40, 151, 895, 585, 975, -1, 809, -1, + 905, 13, 809, -1, 583, -1, 584, 518, 583, -1, + 514, 584, 515, -1, -1, 32, 381, 541, 587, -1, + 32, 381, 191, 152, 541, 587, -1, 590, -1, 587, + 590, -1, 476, -1, 500, -1, -1, 4, -1, 505, + 4, -1, 506, 4, -1, 592, -1, 40, 777, -1, + 60, 589, -1, 106, -1, 272, 106, -1, 201, 591, + 589, -1, 250, 589, -1, 260, 589, -1, 272, 250, + -1, 272, 260, -1, 304, 59, 902, -1, 381, 265, + 902, -1, 400, 588, 589, -1, 356, -1, 356, 588, + 589, -1, 59, -1, -1, 898, -1, 505, 898, -1, + 506, 898, -1, 137, 580, 377, 542, 594, -1, 137, + 580, 377, 191, 152, 542, 594, -1, -1, 171, 3, + -1, 22, 596, -1, 52, 596, -1, 400, 596, -1, + 86, 596, -1, 143, 596, -1, 363, 596, -1, 479, + -1, 430, -1, -1, 452, 541, -1, 100, 644, 416, + 541, 514, 631, 515, 620, 612, -1, 100, 644, 416, + 191, 274, 152, 541, 514, 631, 515, 620, 612, -1, + 100, 294, 352, 644, 416, 541, 514, 631, 515, 620, + 612, -1, -1, 599, 624, -1, 639, -1, 983, -1, + 848, -1, 589, -1, 544, -1, 273, -1, 514, 587, + 515, -1, -1, 544, -1, 272, 25, -1, 357, -1, + 63, -1, 386, 279, -1, 386, 117, -1, 93, 895, + 605, -1, 605, -1, 619, -1, 80, 902, -1, 274, + 279, -1, 279, -1, 445, 630, -1, 328, 226, 630, + -1, 74, 514, 809, 515, 614, -1, 454, 88, 895, + -1, 117, 810, -1, 344, 541, 633, 642, 611, -1, + 468, -1, 406, -1, 606, -1, -1, 175, 645, 40, + 190, 601, -1, 175, 645, 40, 514, 809, 515, 607, + -1, 40, 514, 809, 515, 607, -1, 623, 602, -1, + 289, 451, 603, -1, 610, -1, 635, -1, 610, 635, + -1, 635, 610, -1, -1, 289, 86, 137, -1, 289, + 86, 122, 366, -1, 289, 86, 327, 366, -1, -1, + 514, 617, 515, -1, 272, 204, -1, -1, 93, 895, + 640, -1, 640, -1, 85, -1, 94, -1, 118, -1, + 190, -1, 203, -1, 402, -1, 405, -1, 30, -1, + 636, -1, 617, 518, 636, -1, 454, 202, 627, -1, + 119, -1, 274, 119, -1, 206, 120, -1, 206, 194, + -1, 476, 613, -1, 476, 287, -1, 478, 287, -1, + -1, 514, 626, 515, -1, 622, 200, 616, -1, 622, + 149, 616, -1, -1, 548, -1, 274, 119, -1, 119, + -1, 206, 194, -1, 206, 120, -1, 274, 456, -1, + 272, 204, -1, 542, 774, 634, -1, 542, 773, 608, + 634, -1, 629, -1, 626, 518, 629, -1, 542, -1, + 625, -1, 643, -1, 615, -1, 548, 503, 600, -1, + 548, -1, 476, 621, -1, -1, 641, -1, 641, 518, + -1, -1, 542, -1, 514, 637, 515, -1, -1, 634, + 604, -1, -1, 289, 122, 603, -1, 548, 503, 600, + -1, 548, -1, 548, 516, 548, 503, 600, -1, 548, + 516, 548, -1, 632, -1, 637, 518, 632, -1, 637, + -1, 637, 518, -1, 774, -1, 899, 903, 509, 439, + -1, 387, 899, 903, 509, 439, -1, 74, 514, 809, + 515, 599, -1, 445, 514, 638, 515, 630, 599, -1, + 445, 618, 599, -1, 328, 226, 514, 638, 515, 630, + 599, -1, 328, 226, 618, 599, -1, 168, 226, 514, + 638, 515, 344, 541, 633, 642, 611, 599, -1, 628, + -1, 641, 518, 628, -1, 248, 172, -1, 248, 308, + -1, 248, 392, -1, -1, 236, 541, 622, -1, 422, + -1, 420, -1, 240, 422, -1, 240, 420, -1, 177, + 422, -1, 177, 420, -1, 448, -1, -1, 33, -1, + 59, 117, -1, 137, 647, 191, 152, 649, 650, -1, + 137, 647, 649, 650, -1, 137, 648, 191, 152, 892, + 650, -1, 137, 648, 892, 650, -1, 137, 651, 895, + 289, 902, 650, -1, 137, 651, 191, 152, 895, 289, + 902, 650, -1, 416, -1, 381, -1, 173, -1, 245, + -1, 245, 416, -1, 466, -1, 249, 466, -1, 202, + -1, 168, 416, -1, 81, -1, 97, -1, 370, -1, + 402, -1, 423, 374, 307, -1, 423, 374, 129, -1, + 423, 374, 421, -1, 423, 374, 90, -1, 439, -1, + 24, 251, -1, 146, 433, -1, 156, -1, 168, 107, + 480, -1, 334, -1, 384, -1, 902, -1, 649, 518, + 902, -1, 63, -1, 357, -1, -1, 319, -1, 367, + -1, 433, -1, 100, 644, 653, 541, 654, 40, 416, + 674, -1, 100, 644, 653, 191, 274, 152, 541, 654, + 40, 416, 674, -1, 100, 294, 352, 644, 653, 541, + 654, 40, 416, 674, -1, 100, 644, 653, 541, 654, + 40, 809, -1, 100, 644, 653, 191, 274, 152, 541, + 654, 40, 809, -1, 100, 294, 352, 644, 653, 541, + 654, 40, 809, -1, 173, -1, 245, -1, 514, 515, + -1, 514, 856, 515, -1, 556, 451, 954, 386, 569, + 741, 955, 562, -1, 98, 669, 541, 633, 667, 658, + 663, 672, 659, 588, 664, -1, 98, 514, 674, 515, + 428, 663, 672, 588, 664, -1, 98, 171, 108, 542, + 428, 542, 657, -1, -1, 514, 370, 515, -1, 514, + 107, 515, -1, 171, -1, 428, -1, 661, 124, 544, + -1, -1, 671, -1, 660, 518, 671, -1, 454, -1, + -1, 40, -1, -1, 333, -1, -1, 668, -1, 514, + 673, 515, -1, 936, -1, 589, -1, 507, -1, 514, + 660, 515, -1, 815, -1, -1, 548, 665, -1, 476, + 287, -1, -1, 668, 670, -1, -1, 55, -1, -1, + 55, -1, 287, -1, 170, -1, 123, 662, 544, -1, + 279, 662, 544, -1, 102, -1, 186, -1, 336, 662, + 544, -1, 145, 662, 544, -1, 167, 336, 637, -1, + 167, 336, 507, -1, 309, 59, 637, -1, 309, 59, + 507, -1, 167, 274, 279, 637, -1, 167, 279, 637, + -1, 141, 544, -1, 936, -1, 544, -1, 403, -1, + 404, -1, 3, 516, 542, -1, 3, -1, 666, -1, + 673, 518, 666, -1, 676, -1, 675, -1, 514, 676, + 515, -1, 514, 675, 515, -1, 514, 965, 515, -1, + 679, -1, 677, 699, -1, 677, 698, 732, 705, -1, + 677, 698, 704, 733, -1, 686, 677, -1, 686, 677, + 699, -1, 686, 677, 698, 732, 705, -1, 686, 677, + 698, 704, 733, -1, 679, -1, 675, -1, 379, 696, + 881, -1, -1, 379, 696, 881, 690, 741, 767, 721, + 730, 824, 731, 709, -1, 379, 695, 883, 690, 741, + 767, 721, 730, 824, 731, 709, -1, 171, 742, 678, + 690, 767, 721, 730, 824, 731, 709, -1, 171, 742, + 379, 695, 883, 690, 767, 721, 730, 824, 731, 709, + -1, 740, -1, 416, 761, -1, 677, 444, 693, 694, + 677, -1, 677, 444, 693, 677, -1, 677, 217, 693, + 677, -1, 677, 147, 693, 677, -1, 681, 744, 454, + 883, -1, 681, 744, 454, 883, 180, 59, 894, -1, + 681, 744, 180, 59, 894, -1, 681, 744, 289, 685, + -1, 681, 744, 289, 685, 180, 59, 894, -1, 681, + 744, 289, 685, 454, 883, -1, 681, 744, 289, 685, + 454, 883, 180, 59, 894, -1, 682, 744, 289, 883, + 219, 265, 895, 680, 894, -1, 682, 744, 289, 883, + -1, 459, -1, 460, -1, 314, -1, 316, -1, 449, + -1, 315, -1, 810, -1, 810, 198, 514, 676, 515, + -1, 747, -1, 683, -1, 684, 518, 683, -1, 684, + -1, 684, 518, -1, 476, 687, -1, 500, 687, -1, + 476, 342, 687, -1, 688, -1, 687, 518, 688, -1, + 895, 904, 40, 689, 514, 909, 515, -1, 249, -1, + 274, 249, -1, -1, 219, 691, -1, -1, 422, 692, + 541, -1, 420, 692, 541, -1, 240, 422, 692, 541, + -1, 240, 420, 692, 541, -1, 177, 422, 692, 541, + -1, 177, 420, 692, 541, -1, 448, 692, 541, -1, + 416, 541, -1, 541, -1, 416, -1, -1, 30, -1, + 132, -1, -1, 59, 265, -1, 132, -1, 132, 289, + 514, 854, 515, -1, 30, -1, -1, 192, 281, -1, + 355, 281, -1, -1, 699, -1, -1, 295, 59, 700, + -1, 295, 59, 30, 702, 703, -1, 701, -1, 700, + 518, 701, -1, 809, 454, 848, 703, -1, 809, 702, + 703, -1, 41, -1, 126, -1, -1, 499, 163, -1, + 499, 230, -1, -1, 706, 707, -1, 707, 706, -1, + 706, -1, 707, -1, 704, -1, -1, 237, 715, -1, + 237, 715, 518, 716, -1, 161, 720, 717, 719, 290, + -1, 161, 720, 719, 290, -1, 286, 716, -1, 286, + 717, 719, -1, 4, 509, -1, 9, 509, -1, 4, + 312, -1, 9, 312, -1, 9, -1, 9, 366, -1, + 454, 368, 711, -1, -1, 542, -1, -1, 710, 514, + 708, 515, 714, -1, 708, -1, 708, 514, 542, 515, + -1, 708, 514, 542, 518, 9, 515, -1, 418, 711, + -1, 712, -1, -1, 351, 514, 9, 515, -1, -1, + 809, -1, 30, -1, 809, 509, -1, 4, 312, -1, + 9, 312, -1, 809, -1, 811, -1, 505, 718, -1, + 506, 718, -1, 898, -1, 4, -1, 365, -1, 366, + -1, 163, -1, 271, -1, 180, 59, 723, -1, 180, + 59, 30, -1, -1, 724, -1, 722, 518, 724, -1, + 722, -1, 722, 518, -1, 809, -1, 725, -1, 727, + -1, 726, -1, 728, -1, 514, 515, -1, 364, 514, + 854, 515, -1, 103, 514, 854, 515, -1, 181, 388, + 514, 723, 515, -1, 181, -1, 182, -1, 185, 809, + -1, -1, 335, 809, -1, -1, 734, -1, 166, 338, + 290, -1, 732, -1, -1, 735, -1, 734, 735, -1, + 736, 737, 738, -1, 166, 451, -1, 166, 272, 226, + 451, -1, 166, 389, -1, 166, 226, 389, -1, 284, + 891, -1, -1, 278, -1, 393, 243, -1, -1, 460, + 514, 854, 515, -1, 739, 518, 514, 854, 515, -1, + 739, -1, 739, 518, -1, 171, 743, -1, -1, 744, + -1, 742, 518, 744, -1, 742, -1, 742, 518, -1, + 761, 756, 713, -1, 762, 757, 713, -1, 740, 755, + 713, -1, 231, 762, 757, -1, 675, 756, 713, -1, + 231, 675, 756, -1, 754, -1, 514, 754, 515, 755, + -1, 744, 314, 514, 883, 166, 750, 745, 515, 756, + -1, 744, 449, 746, 514, 751, 166, 753, 515, 756, + -1, 180, 59, 893, -1, -1, 199, 281, -1, 148, + 281, -1, -1, 810, 198, 514, 883, 515, -1, 810, + 198, 543, -1, -1, 812, -1, 814, -1, 514, 852, + 515, -1, 748, 198, 514, 883, 515, -1, 748, 198, + 543, -1, 749, -1, 750, 749, -1, 543, -1, 514, + 893, 515, -1, 751, 198, 514, 883, 515, -1, 752, + -1, 753, 752, -1, 514, 754, 515, -1, 744, 101, + 224, 744, -1, 744, 758, 224, 744, 760, -1, 744, + 224, 744, 760, -1, 744, 268, 758, 224, 744, -1, + 744, 268, 224, 744, -1, 744, 42, 758, 224, 744, + 760, -1, 744, 42, 224, 744, 760, -1, 744, 321, + 224, 744, -1, 744, 37, 224, 744, 760, -1, 744, + 380, 224, 744, 760, -1, 40, 543, 514, 893, 515, + -1, 40, 543, -1, 542, 514, 893, 515, -1, 542, + -1, 755, -1, -1, 755, -1, 40, 514, 768, 515, + -1, 40, 543, 514, 768, 515, -1, 542, 514, 768, + 515, -1, -1, 172, 759, -1, 234, 759, -1, 361, + 759, -1, 380, -1, 37, -1, 208, -1, 299, -1, + -1, 454, 514, 893, 515, -1, 289, 809, -1, 541, + -1, 541, 507, -1, 290, 541, -1, 290, 514, 541, + 515, -1, 818, 766, -1, 366, 171, 514, 764, 515, + 766, -1, 818, 765, -1, 763, -1, 764, 518, 763, + -1, 40, 514, 768, 515, -1, -1, 500, 296, -1, + -1, 473, 809, -1, -1, 769, -1, 768, 518, 769, + -1, 543, 774, 770, -1, 80, 902, -1, -1, 542, + 774, -1, 771, 518, 542, 774, -1, 365, -1, 409, + -1, 774, -1, -1, 777, 776, -1, 387, 777, 776, + -1, 777, 39, 512, 898, 513, -1, 387, 777, 39, + 512, 898, 513, -1, 777, 39, -1, 387, 777, 39, + -1, 775, -1, 772, 514, 771, 515, 776, -1, 246, + 514, 858, 515, 776, -1, 444, 514, 771, 515, 776, + -1, 3, 516, 3, -1, 775, 516, 3, -1, 776, + 512, 513, -1, 776, 512, 898, 513, -1, -1, 779, + -1, 781, -1, 783, -1, 787, -1, 793, -1, 794, + 808, -1, 794, 514, 898, 515, -1, 781, -1, 784, + -1, 788, -1, 793, -1, 901, 780, -1, 514, 855, + 515, -1, -1, 215, -1, 216, -1, 394, -1, 54, + -1, 339, -1, 164, 782, -1, 136, 324, -1, 115, + 780, -1, 112, 780, -1, 282, 780, -1, 57, -1, + 514, 898, 515, -1, -1, 785, -1, 786, -1, 785, + -1, 786, -1, 56, 792, 514, 854, 515, -1, 56, + 792, -1, 789, -1, 790, -1, 789, -1, 790, -1, + 791, 514, 898, 515, -1, 791, -1, 72, 792, -1, + 71, 792, -1, 461, -1, 267, 72, 792, -1, 267, + 71, 792, -1, 269, 792, -1, 463, -1, -1, 427, + 514, 898, 515, 795, -1, 427, 795, -1, 426, 514, + 898, 515, 795, -1, 426, 795, -1, 218, -1, 500, + 426, 497, -1, 478, 426, 497, -1, -1, 494, -1, + 495, -1, 262, -1, 263, -1, 109, -1, 110, -1, + 188, -1, 189, -1, 258, -1, 259, -1, 375, -1, + 376, -1, 256, -1, 257, -1, 252, -1, 253, -1, + 470, -1, 471, -1, 113, -1, 114, -1, 69, -1, + 68, -1, 255, -1, 254, -1, 796, -1, 797, -1, + 798, -1, 799, -1, 800, -1, 801, -1, 802, -1, + 803, -1, 804, -1, 805, -1, 806, -1, 807, -1, + 796, 428, 797, -1, 798, 428, 799, -1, 798, 428, + 800, -1, 798, 428, 801, -1, 799, 428, 800, -1, + 799, 428, 801, -1, 800, 428, 801, -1, -1, 811, + -1, 809, 11, 774, -1, 809, 80, 902, -1, 809, + 46, 426, 497, 809, -1, 505, 809, -1, 506, 809, + -1, 809, 505, 809, -1, 809, 506, 809, -1, 809, + 507, 809, -1, 809, 508, 809, -1, 809, 15, 809, + -1, 809, 509, 809, -1, 809, 510, 809, -1, 809, + 16, 809, -1, 809, 501, 809, -1, 809, 502, 809, + -1, 809, 503, 809, -1, 809, 19, 809, -1, 809, + 20, 809, -1, 809, 21, 809, -1, 809, 847, 809, + -1, 847, 809, -1, 809, 847, -1, 809, 36, 809, + -1, 809, 294, 809, -1, 274, 809, -1, 498, 809, + -1, 809, 176, 809, -1, 809, 236, 809, -1, 809, + 236, 809, 145, 809, -1, 809, 498, 236, 809, -1, + 809, 498, 236, 809, 145, 809, -1, 809, 193, 809, + -1, 809, 193, 809, 145, 809, -1, 809, 498, 193, + 809, -1, 809, 498, 193, 809, 145, 809, -1, 809, + 391, 428, 809, -1, 809, 391, 428, 809, 145, 809, + -1, 809, 498, 391, 428, 809, -1, 809, 498, 391, + 428, 809, 145, 809, -1, 809, 221, 279, -1, 809, + 222, -1, 809, 221, 274, 279, -1, 809, 274, 279, + -1, 809, 277, -1, 809, 17, 809, -1, 809, 18, + 809, -1, 836, 301, 836, -1, 809, 221, 435, -1, + 809, 221, 274, 435, -1, 809, 221, 159, -1, 809, + 221, 274, 159, -1, 809, 221, 446, -1, 809, 221, + 274, 446, -1, 809, 221, 132, 171, 809, -1, 809, + 221, 274, 132, 171, 809, -1, 809, 221, 284, 514, + 858, 515, -1, 809, 221, 274, 284, 514, 858, 515, + -1, 809, 53, 880, 810, 36, 809, -1, 809, 498, + 53, 880, 810, 36, 809, -1, 809, 53, 413, 810, + 36, 809, -1, 809, 498, 53, 413, 810, 36, 809, + -1, 809, 198, 868, -1, 809, 498, 198, 868, -1, + 809, 849, 844, 675, -1, 809, 849, 844, 514, 809, + 515, -1, 117, -1, 83, 514, 809, 515, -1, 507, + 886, 890, -1, 542, 516, 507, 886, 890, -1, 811, + -1, 810, 11, 774, -1, 505, 810, -1, 506, 810, + -1, 810, 505, 810, -1, 810, 506, 810, -1, 810, + 507, 810, -1, 810, 508, 810, -1, 810, 15, 810, + -1, 810, 509, 810, -1, 810, 510, 810, -1, 810, + 16, 810, -1, 810, 501, 810, -1, 810, 502, 810, + -1, 810, 503, 810, -1, 810, 19, 810, -1, 810, + 20, 810, -1, 810, 21, 810, -1, 810, 847, 810, + -1, 847, 810, -1, 810, 847, -1, 810, 221, 132, + 171, 810, -1, 810, 221, 274, 132, 171, 810, -1, + 810, 221, 284, 514, 858, 515, -1, 810, 221, 274, + 284, 514, 858, 515, -1, 812, -1, 813, 879, -1, + 874, -1, 897, -1, 675, -1, 675, 545, -1, 152, + 675, -1, 729, 514, 854, 515, -1, 514, 809, 515, + -1, 814, -1, 836, -1, 519, -1, 10, -1, 815, + -1, 246, 520, 843, 521, -1, 817, -1, 869, -1, + 512, 855, 513, -1, 820, -1, 39, 675, -1, 39, + 512, 855, 513, -1, 522, 9, -1, 523, 548, -1, + 520, 839, 521, -1, 896, 514, 515, -1, 896, 514, + 856, 698, 697, 515, -1, 896, 514, 462, 857, 698, + 697, 515, -1, 896, 514, 856, 518, 462, 857, 698, + 697, 515, -1, 896, 514, 30, 856, 698, 697, 515, + -1, 896, 514, 132, 856, 698, 697, 515, -1, 816, + 821, 822, 823, 827, -1, 819, -1, 816, -1, 819, + -1, 81, 166, 514, 809, 515, -1, 66, 514, 809, + 40, 774, 515, -1, 438, 514, 809, 40, 774, 515, + -1, 158, 514, 859, 515, -1, 302, 514, 861, 515, + -1, 320, 514, 863, 515, -1, 411, 514, 864, 515, + -1, 432, 514, 809, 40, 774, 515, -1, 434, 514, + 58, 867, 515, -1, 434, 514, 232, 867, 515, -1, + 434, 514, 429, 867, 515, -1, 434, 514, 867, 515, + -1, 280, 514, 809, 518, 809, 515, -1, 79, 514, + 854, 515, -1, 512, 809, 166, 542, 198, 809, 513, + -1, 512, 809, 166, 542, 198, 811, 191, 809, 513, + -1, 477, 180, 514, 699, 515, -1, -1, 162, 514, + 473, 809, 515, -1, 162, 514, 809, 515, -1, -1, + 155, -1, -1, 475, 825, -1, -1, 826, -1, 825, + 518, 826, -1, 542, 40, 828, -1, 300, 828, -1, + 300, 542, -1, -1, 514, 829, 830, 698, 831, 515, + -1, 542, -1, -1, 309, 59, 853, -1, -1, 337, + 832, 834, -1, 366, 832, 834, -1, 183, 832, 834, + -1, -1, 833, -1, 53, 833, 36, 833, -1, 441, + 323, -1, 441, 165, -1, 104, 365, -1, 809, 323, + -1, 809, 165, -1, 148, 104, 365, -1, 148, 180, + -1, 148, 425, -1, 148, 272, 297, -1, -1, 365, + 514, 854, 515, -1, 365, 514, 515, -1, 835, -1, + 514, 853, 518, 809, 515, -1, 543, 524, 809, -1, + 837, -1, 838, 518, 837, -1, 838, -1, 838, 518, + -1, 809, 524, 809, -1, 840, -1, 841, 518, 840, + -1, 841, -1, 841, 518, -1, 842, -1, -1, 38, + -1, 396, -1, 30, -1, 8, -1, 846, -1, 505, + -1, 506, -1, 507, -1, 508, -1, 15, -1, 509, + -1, 510, -1, 16, -1, 501, -1, 502, -1, 503, + -1, 19, -1, 20, -1, 21, -1, 8, -1, 291, + 514, 850, 515, -1, 845, -1, 291, 514, 850, 515, + -1, 845, -1, 291, 514, 850, 515, -1, 236, -1, + 498, 236, -1, 176, -1, 498, 176, -1, 193, -1, + 498, 193, -1, 845, -1, 542, 516, 850, -1, 811, + -1, 851, 518, 811, -1, 851, -1, 851, 518, -1, + 809, -1, 853, 518, 809, -1, 853, -1, 853, 518, + -1, 854, -1, -1, 857, -1, 856, 518, 857, -1, + 809, -1, 905, 13, 809, -1, 905, 14, 809, -1, + 774, -1, 858, 518, 774, -1, 860, 171, 809, -1, + -1, 3, -1, 796, -1, 797, -1, 798, -1, 799, + -1, 800, -1, 801, -1, 802, -1, 803, -1, 804, + -1, 805, -1, 806, -1, 807, -1, 544, -1, 809, + 862, 865, 866, -1, 809, 862, 865, -1, 317, 809, + -1, 810, 198, 810, -1, -1, 809, 865, 866, -1, + 809, 866, 865, -1, 809, 865, -1, 809, 866, -1, + 853, -1, -1, 171, 809, -1, 166, 809, -1, 809, + 171, 854, -1, 171, 854, -1, 854, -1, 675, -1, + 514, 854, 515, -1, 65, 873, 870, 872, 143, -1, + 871, -1, 870, 871, -1, 472, 809, 424, 809, -1, + 139, 809, -1, -1, 809, -1, -1, 542, -1, 542, + 545, -1, 512, 809, 513, -1, 512, 875, 524, 875, + 513, -1, 512, 875, 524, 875, 524, 875, 513, -1, + 512, 875, 524, 506, 524, 875, 513, -1, 809, -1, + -1, -1, 876, 546, -1, -1, 514, 515, -1, 514, + 856, 515, -1, 516, 547, 877, -1, 512, 809, 513, + -1, 512, 875, 524, 875, 513, -1, 512, 875, 524, + 875, 524, 875, 513, -1, 512, 875, 524, 506, 524, + 875, 513, -1, -1, 879, 878, -1, 45, -1, -1, + 883, -1, -1, 884, -1, 882, 518, 884, -1, 882, + -1, 882, 518, -1, 809, 40, 906, -1, 809, 3, + -1, 809, -1, 148, 514, 893, 515, -1, 148, 542, + -1, 885, -1, -1, 809, 40, 542, -1, 887, -1, + 888, 518, 887, -1, 888, -1, 888, 518, -1, 352, + 514, 889, 515, -1, 352, 887, -1, -1, 541, -1, + 891, 518, 541, -1, 895, -1, 892, 518, 895, -1, + 892, -1, 892, 518, -1, 893, -1, 514, 893, 515, + -1, 543, -1, 900, -1, 542, 545, -1, 898, -1, + 4, -1, 544, 876, -1, 6, -1, 7, -1, 896, + 544, -1, 896, 514, 856, 698, 697, 515, 544, -1, + 778, 544, -1, 794, 514, 809, 515, 808, -1, 794, + 898, 808, -1, 794, 544, 808, -1, 435, -1, 159, + -1, 279, -1, 9, -1, 3, -1, 977, -1, 982, + -1, 3, -1, 977, -1, 979, -1, 3, -1, 977, + -1, 980, -1, 542, -1, 542, 903, -1, 516, 547, + -1, 903, 516, 547, -1, 514, 893, 515, -1, -1, + 899, -1, 548, -1, 5, -1, 325, 895, 908, 40, + 909, -1, 514, 858, 515, -1, -1, 674, -1, 551, + -1, 655, -1, 656, -1, 953, -1, 965, -1, 100, + 370, 541, 911, -1, 100, 370, 191, 274, 152, 541, + 911, -1, 100, 294, 352, 370, 541, 911, -1, 911, + 912, -1, -1, 598, -1, 913, -1, 576, -1, 972, + -1, 100, 919, 202, 916, 917, 289, 541, 915, 514, + 570, 515, 918, 767, -1, 100, 919, 202, 916, 191, + 274, 152, 627, 289, 541, 915, 514, 570, 515, 918, + 767, -1, 542, -1, 454, 914, -1, -1, 89, -1, + -1, 627, -1, -1, 476, 613, -1, -1, 445, -1, + -1, 32, 416, 761, 386, 370, 895, -1, 32, 416, + 191, 152, 761, 386, 370, 895, -1, 32, 381, 541, + 386, 370, 895, -1, 32, 381, 191, 152, 541, 386, + 370, 895, -1, 32, 466, 541, 386, 370, 895, -1, + 32, 466, 191, 152, 541, 386, 370, 895, -1, 167, + 75, 922, -1, 75, 922, -1, 542, -1, -1, 84, + 289, 925, 541, 221, 924, -1, 84, 289, 82, 809, + 221, 924, -1, 544, -1, 279, -1, 416, -1, 381, + -1, 173, -1, 245, -1, 245, 416, -1, 466, -1, + 108, -1, 202, -1, 370, -1, 439, -1, 154, 108, + 544, 664, -1, 154, 108, 542, 428, 544, 664, -1, + 197, 108, 544, -1, 153, 931, -1, 153, 935, 929, + 931, -1, 153, 464, 931, -1, 153, 514, 934, 515, + 931, -1, 464, -1, -1, 936, -1, 589, -1, -1, + 920, -1, 586, -1, 529, -1, 971, -1, 921, -1, + 656, -1, 974, -1, 652, -1, 910, -1, 576, -1, + 598, -1, 572, -1, 540, -1, 953, -1, 646, -1, + 582, -1, 913, -1, 551, -1, 945, -1, 575, -1, + 907, -1, 549, -1, 674, -1, 595, -1, 655, -1, + 948, -1, 962, -1, 939, -1, 965, -1, 972, -1, + 3, -1, 977, -1, 981, -1, 932, -1, 544, -1, + 937, -1, 934, 518, 937, -1, 35, -1, 34, -1, + 435, -1, 159, -1, 289, -1, 933, -1, 938, 930, + -1, 932, -1, 935, -1, 386, 940, -1, 386, 240, + 940, -1, 386, 385, 940, -1, 386, 177, 940, -1, + 941, -1, 969, 171, 104, -1, 426, 497, 943, -1, + 370, 544, -1, 969, 428, 944, -1, 969, 503, 944, + -1, 809, -1, 544, -1, 3, -1, 794, 544, 808, + -1, 794, 514, 898, 515, 544, -1, 589, -1, 117, + -1, 240, -1, 942, -1, 944, 518, 942, -1, 239, + 946, -1, 213, 946, -1, 167, 213, 946, -1, 213, + 946, 171, 947, -1, 167, 213, 946, 171, 947, -1, + 544, -1, 542, -1, 544, -1, 542, -1, 455, 950, + 952, 929, -1, 455, 950, 952, 929, 541, 904, -1, + 455, 950, 952, 929, 957, -1, 455, 514, 951, 515, + -1, 455, 514, 951, 515, 541, 904, -1, 935, -1, + 464, -1, 170, -1, 172, -1, 3, -1, 172, -1, + -1, 949, -1, 951, 518, 949, -1, 170, -1, -1, + 556, 122, 171, 954, 956, 955, 562, -1, 436, 692, + 954, -1, 761, -1, 761, 542, -1, 761, 40, 542, + -1, 473, 809, -1, -1, 454, 743, -1, -1, 935, + 929, -1, 935, 929, 541, 904, -1, 47, 960, 544, + 961, 664, -1, 47, 191, 274, 152, 960, 544, 961, + 664, -1, 128, 548, -1, 128, 108, 548, -1, 128, + 108, 191, 152, 548, -1, 108, -1, -1, 40, 542, + -1, -1, 354, 964, -1, 354, 240, 964, -1, 354, + 385, 964, -1, 354, 177, 964, -1, 969, -1, 30, + -1, 963, -1, 426, 497, -1, 430, 223, 235, -1, + 967, 674, -1, 412, 674, -1, 412, 970, -1, 967, + 970, -1, 967, 426, 497, -1, 967, 430, 223, 235, + -1, 967, 30, 968, -1, 967, -1, 127, -1, 126, + -1, 390, -1, 966, -1, 417, -1, -1, 542, -1, + 969, 516, 542, -1, 542, -1, 970, 516, 542, -1, + 61, 816, -1, 100, 644, 466, 541, 633, 918, 40, + 674, 973, -1, 100, 644, 466, 191, 274, 152, 541, + 633, 918, 40, 674, 973, -1, 100, 294, 352, 644, + 466, 541, 633, 918, 40, 674, 973, -1, 100, 644, + 342, 466, 541, 514, 637, 515, 918, 40, 674, 973, + -1, 100, 294, 352, 644, 342, 466, 541, 514, 637, + 515, 918, 40, 674, 973, -1, 476, 74, 292, -1, + 476, 64, 74, 292, -1, 476, 240, 74, 292, -1, + -1, 100, 644, 416, 976, 40, 674, 975, -1, 100, + 644, 416, 191, 274, 152, 976, 40, 674, 975, -1, + 100, 294, 352, 644, 416, 976, 40, 674, 975, -1, + 476, 107, -1, 476, 272, 107, -1, -1, 541, 633, + 620, 612, -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, 160, -1, 162, + -1, 163, -1, 165, -1, 167, -1, 169, -1, 173, + -1, 174, -1, 177, -1, 179, -1, 183, -1, 184, + -1, 186, -1, 187, -1, 188, -1, 189, -1, 190, + -1, 191, -1, 192, -1, 194, -1, 195, -1, 196, + -1, 197, -1, 199, -1, 200, -1, 201, -1, 202, + -1, 203, -1, 204, -1, 205, -1, 207, -1, 210, + -1, 211, -1, 212, -1, 213, -1, 214, -1, 220, + -1, 223, -1, 225, -1, 226, -1, 227, -1, 228, + -1, 229, -1, 230, -1, 233, -1, 235, -1, 238, + -1, 239, -1, 240, -1, 241, -1, 242, -1, 243, + -1, 244, -1, 245, -1, 247, -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, 270, -1, 271, -1, 272, + -1, 275, -1, 276, -1, 278, -1, 281, -1, 283, + -1, 284, -1, 285, -1, 287, -1, 288, -1, 291, + -1, 292, -1, 293, -1, 296, -1, 297, -1, 300, + -1, 303, -1, 304, -1, 305, -1, 306, -1, 307, + -1, 308, -1, 309, -1, 310, -1, 311, -1, 312, + -1, 313, -1, 318, -1, 319, -1, 322, -1, 323, + -1, 325, -1, 326, -1, 327, -1, 329, -1, 330, + -1, 331, -1, 332, -1, 333, -1, 334, -1, 336, + -1, 337, -1, 338, -1, 340, -1, 341, -1, 342, + -1, 343, -1, 345, -1, 346, -1, 347, -1, 348, + -1, 349, -1, 350, -1, 351, -1, 352, -1, 353, + -1, 354, -1, 355, -1, 356, -1, 357, -1, 359, + -1, 360, -1, 362, -1, 363, -1, 364, -1, 366, + -1, 367, -1, 368, -1, 369, -1, 370, -1, 371, + -1, 372, -1, 373, -1, 374, -1, 375, -1, 376, + -1, 377, -1, 378, -1, 381, -1, 382, -1, 383, + -1, 384, -1, 385, -1, 386, -1, 388, -1, 389, + -1, 392, -1, 393, -1, 395, -1, 397, -1, 398, + -1, 399, -1, 400, -1, 401, -1, 402, -1, 403, + -1, 404, -1, 405, -1, 406, -1, 407, -1, 408, + -1, 410, -1, 414, -1, 415, -1, 417, -1, 419, + -1, 420, -1, 421, -1, 422, -1, 423, -1, 425, + -1, 430, -1, 431, -1, 433, -1, 436, -1, 437, + -1, 439, -1, 440, -1, 441, -1, 442, -1, 443, + -1, 446, -1, 447, -1, 448, -1, 450, -1, 451, + -1, 452, -1, 453, -1, 455, -1, 456, -1, 457, + -1, 458, -1, 459, -1, 463, -1, 465, -1, 466, + -1, 467, -1, 468, -1, 469, -1, 470, -1, 471, + -1, 474, -1, 477, -1, 478, -1, 479, -1, 480, + -1, 481, -1, 482, -1, 494, -1, 495, -1, 496, + -1, 497, -1, 53, -1, 54, -1, 56, -1, 57, + -1, 71, -1, 72, -1, 79, -1, 83, -1, 112, + -1, 115, -1, 152, -1, 158, -1, 164, -1, 175, + -1, 181, -1, 182, -1, 209, -1, 215, -1, 216, + -1, 218, -1, 246, -1, 267, -1, 269, -1, 273, + -1, 280, -1, 282, -1, 298, -1, 302, -1, 320, + -1, 324, -1, 339, -1, 365, -1, 387, -1, 394, + -1, 409, -1, 411, -1, 426, -1, 427, -1, 432, + -1, 434, -1, 438, -1, 460, -1, 461, -1, 483, + -1, 484, -1, 485, -1, 486, -1, 487, -1, 488, + -1, 489, -1, 490, -1, 491, -1, 492, -1, 493, + -1, 42, -1, 49, -1, 55, -1, 81, -1, 89, + -1, 101, -1, 170, -1, 172, -1, 175, -1, 176, + -1, 193, -1, 208, -1, 221, -1, 222, -1, 224, + -1, 234, -1, 236, -1, 246, -1, 268, -1, 277, + -1, 299, -1, 301, -1, 321, -1, 361, -1, 391, + -1, 409, -1, 418, -1, 464, -1, 37, -1, 42, + -1, 49, -1, 55, -1, 81, -1, 83, -1, 89, + -1, 101, -1, 170, -1, 172, -1, 176, -1, 193, + -1, 208, -1, 221, -1, 222, -1, 224, -1, 234, + -1, 236, -1, 268, -1, 277, -1, 299, -1, 301, + -1, 321, -1, 361, -1, 380, -1, 391, -1, 418, + -1, 438, -1, 464, -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, 158, -1, 164, -1, 170, -1, 172, -1, 175, + -1, 176, -1, 181, -1, 182, -1, 193, -1, 208, + -1, 209, -1, 216, -1, 218, -1, 215, -1, 221, + -1, 222, -1, 224, -1, 234, -1, 236, -1, 246, + -1, 267, -1, 268, -1, 269, -1, 273, -1, 277, + -1, 280, -1, 282, -1, 299, -1, 298, -1, 301, + -1, 302, -1, 320, -1, 321, -1, 324, -1, 339, + -1, 361, -1, 365, -1, 380, -1, 387, -1, 391, + -1, 394, -1, 409, -1, 411, -1, 418, -1, 426, + -1, 427, -1, 432, -1, 434, -1, 438, -1, 460, + -1, 461, -1, 464, -1, 483, -1, 484, -1, 485, + -1, 486, -1, 487, -1, 488, -1, 489, -1, 490, + -1, 491, -1, 492, -1, 493, -1, 37, -1, 42, + -1, 49, -1, 55, -1, 81, -1, 83, -1, 89, + -1, 101, -1, 170, -1, 172, -1, 175, -1, 176, + -1, 193, -1, 208, -1, 221, -1, 222, -1, 224, + -1, 234, -1, 236, -1, 246, -1, 268, -1, 277, + -1, 299, -1, 301, -1, 321, -1, 361, -1, 380, + -1, 391, -1, 409, -1, 418, -1, 438, -1, 464, + -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, 159, -1, 161, -1, 166, -1, 168, + -1, 171, -1, 178, -1, 180, -1, 185, -1, 198, + -1, 206, -1, 217, -1, 219, -1, 231, -1, 232, + -1, 237, -1, 274, -1, 279, -1, 286, -1, 289, + -1, 290, -1, 294, -1, 295, -1, 314, -1, 315, + -1, 316, -1, 317, -1, 328, -1, 335, -1, 344, + -1, 358, -1, 379, -1, 390, -1, 396, -1, 412, + -1, 413, -1, 416, -1, 424, -1, 428, -1, 429, + -1, 435, -1, 444, -1, 445, -1, 449, -1, 454, + -1, 462, -1, 472, -1, 473, -1, 475, -1, 476, + -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint16 yyrline[] = { 0, 500, 500, 516, 528, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, @@ -388255,103 +392509,104 @@ static const yytype_int16 yyrline[] = 214, 218, 226, 231, 232, 233, 234, 235, 241, 245, 47, 48, 52, 53, 54, 72, 73, 80, 88, 96, 104, 112, 120, 131, 132, 159, 164, 172, 188, 205, - 222, 239, 240, 259, 263, 267, 271, 275, 284, 294, - 303, 312, 322, 332, 343, 357, 374, 374, 378, 378, - 382, 382, 386, 392, 399, 403, 404, 408, 409, 423, - 430, 437, 447, 448, 451, 464, 465, 466, 470, 481, - 489, 494, 499, 504, 509, 517, 525, 530, 535, 542, - 543, 547, 548, 549, 553, 560, 561, 565, 566, 570, - 571, 572, 576, 577, 581, 582, 598, 599, 602, 611, - 622, 623, 624, 627, 628, 629, 633, 634, 635, 636, - 640, 641, 645, 647, 663, 665, 670, 673, 681, 685, - 689, 693, 697, 701, 708, 713, 720, 721, 725, 730, - 734, 738, 746, 753, 754, 759, 760, 764, 765, 770, - 772, 774, 779, 799, 800, 802, 807, 808, 812, 813, - 816, 817, 842, 843, 848, 852, 853, 857, 858, 862, - 863, 864, 865, 866, 870, 883, 890, 897, 904, 905, - 909, 910, 914, 915, 919, 920, 924, 925, 929, 930, - 934, 945, 946, 947, 948, 952, 953, 958, 959, 960, - 969, 975, 984, 985, 998, 999, 1003, 1004, 1008, 1009, - 1015, 1021, 1029, 1038, 1046, 1055, 1064, 1068, 1073, 1083, - 1096, 1097, 1100, 1101, 1102, 1105, 1113, 1123, 1124, 1127, - 1135, 1144, 1148, 1155, 1156, 1160, 1169, 1173, 1198, 1202, - 1215, 1229, 1244, 1256, 1269, 1283, 1297, 1310, 1325, 1344, - 1350, 1355, 1361, 1368, 1369, 1377, 1381, 1385, 1391, 1398, - 1403, 1404, 1405, 1406, 1407, 1408, 1412, 1413, 1425, 1426, - 1431, 1438, 1445, 1452, 1484, 1495, 1508, 1513, 1514, 1517, - 1518, 1521, 1522, 1527, 1528, 1533, 1537, 1543, 1564, 1572, - 1585, 1588, 1592, 1592, 1595, 1596, 1598, 1603, 1610, 1615, - 1621, 1626, 1632, 1636, 1643, 1650, 1660, 1661, 1665, 1667, - 1670, 1674, 1675, 1676, 1677, 1678, 1679, 1684, 1704, 1705, - 1706, 1707, 1718, 1732, 1733, 1739, 1744, 1749, 1754, 1759, - 1764, 1769, 1774, 1780, 1786, 1792, 1799, 1821, 1830, 1834, - 1842, 1846, 1854, 1866, 1887, 1891, 1897, 1901, 1914, 1922, - 1932, 1934, 1936, 1938, 1940, 1942, 1947, 1948, 1955, 1964, - 1972, 1981, 1992, 2000, 2001, 2002, 2006, 2006, 2009, 2009, - 2012, 2012, 2015, 2015, 2018, 2018, 2021, 2021, 2024, 2024, - 2027, 2027, 2030, 2030, 2033, 2033, 2036, 2036, 2039, 2039, - 2042, 2044, 2046, 2048, 2050, 2052, 2054, 2056, 2058, 2060, - 2062, 2064, 2066, 2071, 2076, 2082, 2089, 2094, 2100, 2106, - 2137, 2139, 2141, 2149, 2164, 2166, 2168, 2170, 2172, 2174, - 2176, 2178, 2180, 2182, 2184, 2186, 2188, 2190, 2192, 2194, - 2197, 2199, 2201, 2204, 2206, 2208, 2210, 2212, 2217, 2222, - 2229, 2234, 2241, 2246, 2253, 2258, 2266, 2274, 2282, 2290, - 2308, 2316, 2324, 2332, 2340, 2348, 2356, 2360, 2376, 2384, - 2392, 2400, 2408, 2416, 2424, 2428, 2432, 2436, 2440, 2448, - 2456, 2464, 2472, 2492, 2514, 2525, 2532, 2546, 2554, 2562, - 2582, 2584, 2586, 2588, 2590, 2592, 2594, 2596, 2598, 2600, - 2602, 2604, 2606, 2608, 2610, 2612, 2614, 2616, 2618, 2620, - 2622, 2624, 2628, 2632, 2636, 2650, 2651, 2655, 2669, 2670, - 2671, 2678, 2682, 2686, 2689, 2700, 2705, 2707, 2718, 2742, - 2753, 2764, 2768, 2775, 2779, 2783, 2800, 2808, 2817, 2821, - 2828, 2836, 2844, 2855, 2875, 2911, 2922, 2923, 2930, 2936, - 2938, 2940, 2944, 2953, 2958, 2965, 2980, 2987, 2991, 2995, - 2999, 3003, 3013, 3022, 3044, 3045, 3049, 3050, 3051, 3055, - 3056, 3063, 3064, 3068, 3069, 3074, 3082, 3084, 3098, 3101, - 3128, 3129, 3132, 3133, 3141, 3149, 3157, 3166, 3176, 3194, - 3240, 3249, 3258, 3267, 3276, 3288, 3289, 3290, 3291, 3292, - 3306, 3307, 3310, 3311, 3315, 3325, 3326, 3330, 3331, 3335, - 3342, 3343, 3348, 3349, 3354, 3355, 3358, 3359, 3360, 3363, - 3364, 3367, 3368, 3369, 3370, 3371, 3372, 3373, 3374, 3375, - 3376, 3377, 3378, 3379, 3380, 3383, 3385, 3390, 3392, 3397, - 3399, 3401, 3403, 3405, 3407, 3409, 3411, 3425, 3427, 3432, - 3436, 3443, 3448, 3454, 3458, 3465, 3470, 3477, 3482, 3490, - 3494, 3500, 3504, 3513, 3524, 3525, 3529, 3533, 3540, 3541, - 3542, 3543, 3544, 3545, 3546, 3547, 3548, 3549, 3550, 3551, - 3552, 3553, 3563, 3567, 3574, 3581, 3582, 3598, 3602, 3607, - 3611, 3626, 3631, 3635, 3638, 3641, 3642, 3643, 3646, 3653, - 3663, 3677, 3678, 3682, 3693, 3694, 3697, 3698, 3701, 3705, - 3712, 3720, 3728, 3736, 3746, 3747, 3752, 3753, 3757, 3758, - 3759, 3763, 3772, 3780, 3788, 3797, 3812, 3813, 3818, 3819, - 3829, 3830, 3834, 3835, 3839, 3840, 3843, 3859, 3867, 3877, - 3878, 3881, 3882, 3885, 3889, 3890, 3894, 3895, 3898, 3899, - 3900, 3910, 3911, 3915, 3917, 3923, 3924, 3928, 3929, 3932, - 3943, 3946, 3957, 3961, 3965, 3977, 3981, 3990, 3997, 4035, - 4039, 4043, 4047, 4051, 4055, 4059, 4065, 4082, 4083, 4084, - 4087, 4088, 4089, 4092, 4093, 4094, 4097, 4098, 4101, 4103, - 4108, 4109, 4112, 4116, 4117, 7, 18, 19, 23, 24, - 25, 26, 27, 28, 7, 26, 50, 73, 80, 85, - 86, 87, 88, 8, 33, 62, 66, 67, 72, 73, - 78, 79, 83, 84, 89, 90, 7, 16, 25, 34, - 43, 52, 5, 12, 22, 23, 7, 15, 26, 27, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 7, 19, 33, 9, 16, 26, 33, 44, 45, 50, - 51, 52, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 90, 91, 92, 97, 98, 103, 107, 115, - 116, 121, 122, 123, 129, 134, 142, 143, 10, 16, - 22, 28, 38, 39, 47, 58, 70, 78, 89, 95, - 99, 103, 118, 125, 126, 127, 131, 132, 7, 15, - 22, 29, 36, 45, 46, 48, 49, 8, 22, 36, - 48, 56, 70, 71, 72, 73, 74, 87, 88, 93, - 94, 98, 99, 7, 18, 31, 35, 42, 53, 54, - 60, 61, 9, 19, 7, 16, 28, 35, 42, 51, - 52, 56, 57, 2, 7, 12, 17, 26, 33, 43, - 44, 51, 3, 10, 17, 24, 31, 38, 45, 52, - 61, 61, 63, 63, 65, 65, 67, 68, 72, 73, - 6, 8, 21, 34, 47, 65, 87, 88, 89, 90, - 11, 24, 37, 54, 55, 56, 61, 74, 74, 74, + 222, 239, 240, 259, 263, 267, 271, 275, 285, 296, + 306, 315, 326, 337, 349, 364, 382, 382, 386, 386, + 390, 390, 394, 400, 407, 411, 412, 416, 417, 431, + 438, 445, 455, 456, 459, 472, 473, 474, 478, 489, + 497, 502, 507, 512, 517, 525, 533, 538, 543, 550, + 551, 555, 556, 557, 561, 568, 569, 573, 574, 578, + 579, 580, 584, 585, 589, 590, 606, 607, 610, 619, + 630, 631, 632, 635, 636, 637, 641, 642, 643, 644, + 648, 649, 653, 655, 671, 673, 678, 681, 689, 693, + 697, 701, 705, 709, 716, 721, 728, 729, 733, 738, + 742, 746, 754, 761, 762, 767, 768, 772, 773, 778, + 780, 782, 787, 807, 808, 810, 815, 816, 820, 821, + 824, 825, 850, 851, 856, 860, 861, 865, 866, 870, + 871, 872, 873, 874, 878, 891, 898, 905, 912, 913, + 917, 918, 922, 923, 927, 928, 932, 933, 937, 938, + 942, 953, 954, 955, 956, 960, 961, 966, 967, 968, + 977, 983, 992, 993, 1006, 1007, 1011, 1012, 1016, 1017, + 1023, 1029, 1037, 1046, 1054, 1063, 1072, 1076, 1081, 1092, + 1106, 1107, 1110, 1111, 1112, 1115, 1123, 1132, 1133, 1134, + 1135, 1138, 1146, 1155, 1159, 1166, 1167, 1171, 1180, 1184, + 1209, 1213, 1226, 1240, 1255, 1267, 1280, 1294, 1308, 1321, + 1336, 1355, 1361, 1366, 1372, 1379, 1380, 1388, 1392, 1396, + 1402, 1409, 1414, 1415, 1416, 1417, 1418, 1419, 1423, 1424, + 1436, 1437, 1442, 1449, 1456, 1463, 1495, 1506, 1519, 1524, + 1525, 1528, 1529, 1532, 1533, 1538, 1539, 1544, 1548, 1554, + 1575, 1583, 1596, 1599, 1603, 1603, 1606, 1607, 1609, 1614, + 1621, 1626, 1632, 1637, 1643, 1647, 1654, 1661, 1671, 1672, + 1676, 1678, 1681, 1685, 1686, 1687, 1688, 1689, 1690, 1695, + 1715, 1716, 1717, 1718, 1729, 1743, 1744, 1750, 1755, 1760, + 1765, 1770, 1775, 1780, 1785, 1791, 1797, 1803, 1810, 1832, + 1841, 1845, 1853, 1857, 1865, 1877, 1898, 1902, 1908, 1912, + 1925, 1933, 1943, 1945, 1947, 1949, 1951, 1953, 1958, 1959, + 1966, 1975, 1983, 1992, 2003, 2011, 2012, 2013, 2017, 2017, + 2020, 2020, 2023, 2023, 2026, 2026, 2029, 2029, 2032, 2032, + 2035, 2035, 2038, 2038, 2041, 2041, 2044, 2044, 2047, 2047, + 2050, 2050, 2053, 2055, 2057, 2059, 2061, 2063, 2065, 2067, + 2069, 2071, 2073, 2075, 2077, 2082, 2087, 2093, 2100, 2105, + 2111, 2117, 2148, 2150, 2152, 2160, 2175, 2177, 2179, 2181, + 2183, 2185, 2187, 2189, 2191, 2193, 2195, 2197, 2199, 2201, + 2203, 2205, 2208, 2210, 2212, 2215, 2217, 2219, 2221, 2223, + 2228, 2233, 2240, 2245, 2252, 2257, 2264, 2269, 2277, 2285, + 2293, 2301, 2319, 2327, 2335, 2343, 2351, 2359, 2367, 2371, + 2387, 2395, 2403, 2411, 2419, 2427, 2435, 2439, 2443, 2447, + 2451, 2459, 2467, 2475, 2483, 2503, 2525, 2536, 2543, 2557, + 2565, 2573, 2593, 2595, 2597, 2599, 2601, 2603, 2605, 2607, + 2609, 2611, 2613, 2615, 2617, 2619, 2621, 2623, 2625, 2627, + 2629, 2631, 2633, 2635, 2639, 2643, 2647, 2661, 2662, 2676, + 2677, 2678, 2689, 2713, 2724, 2734, 2738, 2742, 2749, 2753, + 2760, 2764, 2781, 2785, 2787, 2791, 2794, 2805, 2810, 2817, + 2825, 2834, 2838, 2845, 2853, 2861, 2872, 2892, 2928, 2939, + 2940, 2947, 2953, 2955, 2957, 2961, 2970, 2975, 2982, 2997, + 3004, 3008, 3012, 3016, 3020, 3030, 3039, 3061, 3062, 3066, + 3067, 3068, 3072, 3073, 3080, 3081, 3085, 3086, 3091, 3099, + 3101, 3115, 3118, 3145, 3146, 3149, 3150, 3158, 3166, 3174, + 3183, 3193, 3211, 3257, 3266, 3275, 3284, 3293, 3305, 3306, + 3307, 3308, 3309, 3323, 3324, 3327, 3328, 3332, 3342, 3343, + 3347, 3348, 3352, 3359, 3360, 3365, 3366, 3371, 3372, 3375, + 3376, 3377, 3380, 3381, 3384, 3385, 3386, 3387, 3388, 3389, + 3390, 3391, 3392, 3393, 3394, 3395, 3396, 3397, 3400, 3402, + 3407, 3409, 3414, 3416, 3418, 3420, 3422, 3424, 3426, 3428, + 3442, 3444, 3449, 3453, 3460, 3465, 3471, 3475, 3482, 3487, + 3494, 3499, 3507, 3511, 3517, 3521, 3530, 3541, 3542, 3546, + 3550, 3557, 3558, 3559, 3560, 3561, 3562, 3563, 3564, 3565, + 3566, 3567, 3568, 3569, 3570, 3580, 3584, 3591, 3598, 3599, + 3615, 3619, 3624, 3628, 3643, 3648, 3652, 3655, 3658, 3659, + 3660, 3663, 3670, 3680, 3694, 3695, 3699, 3710, 3711, 3714, + 3715, 3718, 3722, 3729, 3737, 3745, 3753, 3763, 3764, 3769, + 3770, 3774, 3775, 3776, 3780, 3789, 3797, 3805, 3814, 3829, + 3830, 3835, 3836, 3846, 3847, 3851, 3852, 3856, 3857, 3860, + 3876, 3884, 3894, 3895, 3898, 3899, 3902, 3906, 3907, 3911, + 3912, 3915, 3916, 3917, 3927, 3928, 3932, 3934, 3940, 3941, + 3945, 3946, 3949, 3960, 3963, 3974, 3978, 3982, 3994, 3998, + 4007, 4014, 4052, 4056, 4060, 4064, 4068, 4072, 4076, 4082, + 4099, 4100, 4101, 4104, 4105, 4106, 4109, 4110, 4111, 4114, + 4115, 4118, 4120, 4125, 4126, 4129, 4133, 4134, 7, 18, + 19, 23, 24, 25, 26, 27, 28, 7, 26, 50, + 73, 80, 85, 86, 87, 88, 8, 33, 62, 66, + 67, 72, 73, 78, 79, 83, 84, 89, 90, 7, + 16, 25, 34, 43, 52, 5, 12, 22, 23, 7, + 15, 26, 27, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 7, 19, 33, 9, 16, 26, 33, + 44, 45, 50, 51, 52, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 90, 91, 92, 97, 98, + 103, 107, 115, 116, 121, 122, 123, 129, 134, 142, + 143, 10, 16, 22, 28, 38, 39, 47, 58, 70, + 78, 89, 95, 99, 103, 118, 125, 126, 127, 131, + 132, 7, 15, 22, 29, 36, 45, 46, 48, 49, + 8, 22, 36, 48, 56, 70, 71, 72, 73, 74, + 87, 88, 93, 94, 98, 99, 7, 18, 31, 35, + 42, 53, 54, 60, 61, 9, 19, 7, 16, 28, + 35, 42, 51, 52, 56, 57, 2, 7, 12, 17, + 26, 33, 43, 44, 51, 3, 10, 17, 24, 31, + 38, 45, 52, 61, 61, 63, 63, 65, 65, 67, + 68, 72, 73, 6, 8, 21, 34, 47, 65, 87, + 88, 89, 90, 11, 24, 37, 54, 55, 56, 61, + 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, @@ -388383,18 +392638,18 @@ static const yytype_int16 yyrline[] = 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, - 74, 74, 74, 74, 74, 74, 74, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, - 75, 76, 76, 76, 76, 76, 76, 76, 76, 76, + 75, 75, 75, 75, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, - 76, 76, 76, 76, 76, 76, 76, 76, 76, 77, + 76, 76, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, 78, 78, + 77, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, @@ -388402,52 +392657,43 @@ static const yytype_int16 yyrline[] = 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, - 78, 78, 78, 78, 78, 78, 78, 78, 78, 79, + 78, 78, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, - 79, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 79, 79, 79, 79, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, - 80, 80, 80, 80, 80, 80 + 80, 80, 80, 80, 80, 80, 80, 80, 80 }; #endif -/** Accessing symbol of state STATE. */ -#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) - -#if YYDEBUG || 0 -/* The user-facing name of the symbol whose (internal) number is - YYSYMBOL. No bounds checking. */ -static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; - +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[] = { - "\"end of file\"", "error", "\"invalid token\"", "IDENT", "FCONST", - "SCONST", "BCONST", "XCONST", "Op", "ICONST", "PARAM", "TYPECAST", - "DOT_DOT", "COLON_EQUALS", "EQUALS_GREATER", "INTEGER_DIVISION", - "POWER_OF", "LAMBDA_ARROW", "DOUBLE_ARROW", "LESS_EQUALS", - "GREATER_EQUALS", "NOT_EQUALS", "ABORT_P", "ABSOLUTE_P", "ACCESS", - "ACTION", "ADD_P", "ADMIN", "AFTER", "AGGREGATE", "ALL", "ALSO", "ALTER", - "ALWAYS", "ANALYSE", "ANALYZE", "AND", "ANTI", "ANY", "ARRAY", "AS", - "ASC_P", "ASOF", "ASSERTION", "ASSIGNMENT", "ASYMMETRIC", "AT", "ATTACH", - "ATTRIBUTE", "AUTHORIZATION", "BACKWARD", "BEFORE", "BEGIN_P", "BETWEEN", - "BIGINT", "BINARY", "BIT", "BOOLEAN_P", "BOTH", "BY", "CACHE", "CALL_P", - "CALLED", "CASCADE", "CASCADED", "CASE", "CAST", "CATALOG_P", - "CENTURIES_P", "CENTURY_P", "CHAIN", "CHAR_P", "CHARACTER", - "CHARACTERISTICS", "CHECK_P", "CHECKPOINT", "CLASS", "CLOSE", "CLUSTER", - "COALESCE", "COLLATE", "COLLATION", "COLUMN", "COLUMNS", "COMMENT", - "COMMENTS", "COMMIT", "COMMITTED", "COMPRESSION", "CONCURRENTLY", - "CONFIGURATION", "CONFLICT", "CONNECTION", "CONSTRAINT", "CONSTRAINTS", - "CONTENT_P", "CONTINUE_P", "CONVERSION_P", "COPY", "COST", "CREATE_P", - "CROSS", "CSV", "CUBE", "CURRENT_P", "CURSOR", "CYCLE", "DATA_P", - "DATABASE", "DAY_P", "DAYS_P", "DEALLOCATE", "DEC", "DECADE_P", + "$end", "error", "$undefined", "IDENT", "FCONST", "SCONST", "BCONST", + "XCONST", "Op", "ICONST", "PARAM", "TYPECAST", "DOT_DOT", "COLON_EQUALS", + "EQUALS_GREATER", "INTEGER_DIVISION", "POWER_OF", "LAMBDA_ARROW", + "DOUBLE_ARROW", "LESS_EQUALS", "GREATER_EQUALS", "NOT_EQUALS", "ABORT_P", + "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", "ADMIN", "AFTER", "AGGREGATE", + "ALL", "ALSO", "ALTER", "ALWAYS", "ANALYSE", "ANALYZE", "AND", "ANTI", + "ANY", "ARRAY", "AS", "ASC_P", "ASOF", "ASSERTION", "ASSIGNMENT", + "ASYMMETRIC", "AT", "ATTACH", "ATTRIBUTE", "AUTHORIZATION", "BACKWARD", + "BEFORE", "BEGIN_P", "BETWEEN", "BIGINT", "BINARY", "BIT", "BOOLEAN_P", + "BOTH", "BY", "CACHE", "CALL_P", "CALLED", "CASCADE", "CASCADED", "CASE", + "CAST", "CATALOG_P", "CENTURIES_P", "CENTURY_P", "CHAIN", "CHAR_P", + "CHARACTER", "CHARACTERISTICS", "CHECK_P", "CHECKPOINT", "CLASS", + "CLOSE", "CLUSTER", "COALESCE", "COLLATE", "COLLATION", "COLUMN", + "COLUMNS", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", "COMPRESSION", + "CONCURRENTLY", "CONFIGURATION", "CONFLICT", "CONNECTION", "CONSTRAINT", + "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", "CONVERSION_P", "COPY", "COST", + "CREATE_P", "CROSS", "CSV", "CUBE", "CURRENT_P", "CURSOR", "CYCLE", + "DATA_P", "DATABASE", "DAY_P", "DAYS_P", "DEALLOCATE", "DEC", "DECADE_P", "DECADES_P", "DECIMAL_P", "DECLARE", "DEFAULT", "DEFAULTS", "DEFERRABLE", "DEFERRED", "DEFINER", "DELETE_P", "DELIMITER", "DELIMITERS", "DEPENDS", "DESC_P", "DESCRIBE", "DETACH", "DICTIONARY", "DISABLE_P", "DISCARD", @@ -388511,27 +392757,29 @@ static const char *const yytname[] = "XMLROOT", "XMLSERIALIZE", "XMLTABLE", "YEAR_P", "YEARS_P", "YES_P", "ZONE", "NOT_LA", "NULLS_LA", "WITH_LA", "'<'", "'>'", "'='", "POSTFIXOP", "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "UMINUS", "'['", - "']'", "'('", "')'", "'.'", "';'", "','", "'#'", "'$'", "'?'", "'{'", - "'}'", "':'", "$accept", "stmtblock", "stmtmulti", "stmt", - "AlterObjectSchemaStmt", "AlterSeqStmt", "SeqOptList", "opt_with", - "NumericOnly", "SeqOptElem", "opt_by", "SignedIconst", "AlterTableStmt", - "alter_identity_column_option_list", "alter_column_default", - "alter_identity_column_option", "alter_generic_option_list", - "alter_table_cmd", "alter_using", "alter_generic_option_elem", - "alter_table_cmds", "alter_generic_options", "opt_set_data", - "AnalyzeStmt", "AttachStmt", "DetachStmt", "opt_database", - "opt_database_alias", "CallStmt", "CheckPointStmt", "opt_col_id", - "CommentOnStmt", "comment_value", "comment_on_type_any_name", - "qualified_name", "ColId", "ColIdOrString", "Sconst", "indirection", - "indirection_el", "attr_name", "ColLabel", "CopyStmt", - "copy_database_flag", "copy_from", "copy_delimiter", - "copy_generic_opt_arg_list", "opt_using", "opt_as", "opt_program", - "copy_options", "copy_generic_opt_arg", "copy_generic_opt_elem", - "opt_oids", "copy_opt_list", "opt_binary", "copy_opt_item", - "copy_generic_opt_arg_list_item", "copy_file_name", - "copy_generic_opt_list", "CreateStmt", "ConstraintAttributeSpec", - "def_arg", "OptParenthesizedSeqOptList", "generic_option_arg", - "key_action", "ColConstraint", "ColConstraintElem", + "']'", "'('", "')'", "'.'", "';'", "','", "'?'", "'{'", "'}'", "'#'", + "'$'", "':'", "$accept", "stmtblock", "stmtmulti", "stmt", + "AlterTableStmt", "alter_identity_column_option_list", + "alter_column_default", "alter_identity_column_option", + "alter_generic_option_list", "alter_table_cmd", "alter_using", + "alter_generic_option_elem", "alter_table_cmds", "alter_generic_options", + "opt_set_data", "DeallocateStmt", "qualified_name", "ColId", + "ColIdOrString", "Sconst", "indirection", "indirection_el", "attr_name", + "ColLabel", "RenameStmt", "opt_column", "InsertStmt", "insert_rest", + "insert_target", "opt_by_name_or_position", "opt_conf_expr", + "opt_with_clause", "insert_column_item", "set_clause", "opt_or_action", + "opt_on_conflict", "index_elem", "returning_clause", "override_kind", + "set_target_list", "opt_collate", "opt_class", "insert_column_list", + "set_clause_list", "set_clause_list_opt_comma", "index_params", + "set_target", "CreateTypeStmt", "opt_enum_val_list", "enum_val_list", + "PragmaStmt", "CreateSeqStmt", "OptSeqOptList", "CreateSecretStmt", + "opt_secret_name", "opt_persist", "opt_storage_specifier", "ExecuteStmt", + "execute_param_expr", "execute_param_list", "execute_param_clause", + "AlterSeqStmt", "SeqOptList", "opt_with", "NumericOnly", "SeqOptElem", + "opt_by", "SignedIconst", "DropSecretStmt", "opt_storage_drop_specifier", + "TransactionStmt", "opt_transaction", "UseStmt", "CreateStmt", + "ConstraintAttributeSpec", "def_arg", "OptParenthesizedSeqOptList", + "generic_option_arg", "key_action", "ColConstraint", "ColConstraintElem", "GeneratedColumnType", "opt_GeneratedColumnType", "GeneratedConstraintElem", "generic_option_elem", "key_update", "key_actions", "OnCommitOption", "reloptions", "opt_no_inherit", @@ -388542,33 +392790,16 @@ static const char *const yytname[] = "OptTableElementList", "columnElem", "opt_column_list", "ColQualList", "key_delete", "reloption_elem", "columnList", "columnList_opt_comma", "func_type", "ConstraintElem", "TableElementList", "key_match", - "TableLikeClause", "OptTemp", "generated_when", "CreateAsStmt", - "opt_with_data", "create_as_target", "unreserved_keyword", - "col_name_keyword", "func_name_keyword", "type_name_keyword", - "other_keyword", "type_func_name_keyword", "reserved_keyword", - "CreateFunctionStmt", "macro_alias", "param_list", "CreateSchemaStmt", - "OptSchemaEltList", "schema_stmt", "CreateSecretStmt", "opt_secret_name", - "opt_persist", "opt_storage_specifier", "CreateSeqStmt", "OptSeqOptList", - "CreateTypeStmt", "opt_enum_val_list", "enum_val_list", "DeallocateStmt", - "DeleteStmt", "relation_expr_opt_alias", "where_or_current_clause", - "using_clause", "DropStmt", "drop_type_any_name", "drop_type_name", - "any_name_list", "opt_drop_behavior", "drop_type_name_on_any_name", - "DropSecretStmt", "opt_storage_drop_specifier", "ExecuteStmt", - "execute_param_expr", "execute_param_list", "execute_param_clause", - "ExplainStmt", "opt_verbose", "explain_option_arg", "ExplainableStmt", - "NonReservedWord", "NonReservedWord_or_Sconst", "explain_option_list", - "analyze_keyword", "opt_boolean_or_string", "explain_option_elem", - "explain_option_name", "ExportStmt", "ImportStmt", "IndexStmt", - "access_method", "access_method_clause", "opt_concurrently", - "opt_index_name", "opt_reloptions", "opt_unique", "InsertStmt", - "insert_rest", "insert_target", "opt_by_name_or_position", - "opt_conf_expr", "opt_with_clause", "insert_column_item", "set_clause", - "opt_or_action", "opt_on_conflict", "index_elem", "returning_clause", - "override_kind", "set_target_list", "opt_collate", "opt_class", - "insert_column_list", "set_clause_list", "set_clause_list_opt_comma", - "index_params", "set_target", "LoadStmt", "file_name", "repo_path", - "PragmaStmt", "PrepareStmt", "prep_type_clause", "PreparableStmt", - "RenameStmt", "opt_column", "SelectStmt", "select_with_parens", + "TableLikeClause", "OptTemp", "generated_when", "DropStmt", + "drop_type_any_name", "drop_type_name", "any_name_list", + "opt_drop_behavior", "drop_type_name_on_any_name", "CreateFunctionStmt", + "macro_alias", "param_list", "UpdateStmt", "CopyStmt", + "copy_database_flag", "copy_from", "copy_delimiter", + "copy_generic_opt_arg_list", "opt_using", "opt_as", "opt_program", + "copy_options", "copy_generic_opt_arg", "copy_generic_opt_elem", + "opt_oids", "copy_opt_list", "opt_binary", "copy_opt_item", + "copy_generic_opt_arg_list_item", "copy_file_name", + "copy_generic_opt_list", "SelectStmt", "select_with_parens", "select_no_parens", "select_clause", "opt_select", "simple_select", "value_or_values", "pivot_keyword", "unpivot_keyword", "pivot_column_entry", "pivot_column_list_internal", "pivot_column_list", @@ -388607,9 +392838,10 @@ static const char *const yytname[] = "millisecond_keyword", "microsecond_keyword", "week_keyword", "decade_keyword", "century_keyword", "millennium_keyword", "opt_interval", "a_expr", "b_expr", "c_expr", "d_expr", - "indirection_expr", "struct_expr", "func_application", "func_expr", - "func_expr_windowless", "func_expr_common_subexpr", "list_comprehension", - "within_group_clause", "filter_clause", "export_clause", "window_clause", + "indirection_expr_or_a_expr", "indirection_expr", "struct_expr", + "func_application", "func_expr", "func_expr_windowless", + "func_expr_common_subexpr", "list_comprehension", "within_group_clause", + "filter_clause", "export_clause", "window_clause", "window_definition_list", "window_definition", "over_clause", "window_specification", "opt_existing_window_name", "opt_partition_clause", "opt_frame_clause", "frame_extent", @@ -388633,1771 +392865,3060 @@ static const char *const yytname[] = "name_list_opt_comma_opt_bracket", "name", "func_name", "AexprConst", "Iconst", "type_function_name", "function_name_token", "type_name_token", "any_name", "attrs", "opt_name_list", "param_name", "ColLabelOrString", - "TransactionStmt", "opt_transaction", "UpdateStmt", "UseStmt", - "VacuumStmt", "vacuum_option_elem", "opt_full", "vacuum_option_list", - "opt_freeze", "VariableResetStmt", "generic_reset", "reset_rest", - "VariableSetStmt", "set_rest", "generic_set", "var_value", "zone_value", - "var_list", "VariableShowStmt", "describe_or_desc", "show_or_describe", - "opt_tables", "var_name", "table_id", "ViewStmt", "opt_check_option", YY_NULLPTR + "PrepareStmt", "prep_type_clause", "PreparableStmt", "CreateSchemaStmt", + "OptSchemaEltList", "schema_stmt", "IndexStmt", "access_method", + "access_method_clause", "opt_concurrently", "opt_index_name", + "opt_reloptions", "opt_unique", "AlterObjectSchemaStmt", + "CheckPointStmt", "opt_col_id", "CommentOnStmt", "comment_value", + "comment_on_type_any_name", "ExportStmt", "ImportStmt", "ExplainStmt", + "opt_verbose", "explain_option_arg", "ExplainableStmt", + "NonReservedWord", "NonReservedWord_or_Sconst", "explain_option_list", + "analyze_keyword", "opt_boolean_or_string", "explain_option_elem", + "explain_option_name", "VariableSetStmt", "set_rest", "generic_set", + "var_value", "zone_value", "var_list", "LoadStmt", "file_name", + "repo_path", "VacuumStmt", "vacuum_option_elem", "opt_full", + "vacuum_option_list", "opt_freeze", "DeleteStmt", + "relation_expr_opt_alias", "where_or_current_clause", "using_clause", + "AnalyzeStmt", "AttachStmt", "DetachStmt", "opt_database", + "opt_database_alias", "VariableResetStmt", "generic_reset", "reset_rest", + "VariableShowStmt", "describe_or_desc", "show_or_describe", "opt_tables", + "var_name", "table_id", "CallStmt", "ViewStmt", "opt_check_option", + "CreateAsStmt", "opt_with_data", "create_as_target", + "unreserved_keyword", "col_name_keyword", "func_name_keyword", + "type_name_keyword", "other_keyword", "type_func_name_keyword", + "reserved_keyword", 0 }; - -static const char * -yysymbol_name (yysymbol_kind_t yysymbol) -{ - return yytname[yysymbol]; -} #endif -#define YYPACT_NINF (-3054) - -#define yypact_value_is_default(Yyn) \ - ((Yyn) == YYPACT_NINF) - -#define YYTABLE_NINF (-2041) - -#define yytable_value_is_error(Yyn) \ - ((Yyn) == YYTABLE_NINF) +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const yytype_uint16 yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, + 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, + 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, + 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, + 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, + 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, + 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, + 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, + 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, + 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, + 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, + 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, + 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, + 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, + 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, + 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, + 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, + 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, + 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, + 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, + 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, + 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, + 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, + 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, + 755, 60, 62, 61, 756, 43, 45, 42, 47, 37, + 94, 757, 91, 93, 40, 41, 46, 59, 44, 63, + 123, 125, 35, 36, 58 +}; +# endif -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -static const int yypact[] = +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint16 yyr1[] = { - 6730, 369, 821, -3054, -3054, 278, 369, 49852, 64687, 414, - 369, 134, 2149, 51832, -3054, -3054, 46387, 8014, 369, 54802, - 72023, 324, 355, 31638, 654, 55297, 55297, -3054, -3054, -3054, - 64687, 54802, 55792, 369, 731, 65182, -3054, 369, 34113, 52327, - 417, -3054, 54802, 40, 97, 56287, 54802, 1995, 842, 340, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, 413, -3054, -3054, -3054, -3054, 111, - -3054, -3054, -3054, -3054, -3054, 151, -3054, 128, 154, 31638, - 31638, 1561, 384, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, 33618, -3054, -3054, -3054, -3054, 56782, 54802, 57277, - 52822, 57772, -3054, 671, 950, -3054, 167, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, 178, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, 186, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, 192, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, 638, 200, -3054, -3054, - -3054, 549, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - 1395, -3054, -3054, 865, 2206, 54802, 830, 836, 689, -3054, - 58267, -3054, 696, 54802, -3054, -3054, 806, 720, 884, -3054, - -3054, 53317, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, 46882, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, 854, -3054, -3054, - 727, -3054, 107, -3054, -3054, 726, 719, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, 795, -3054, -3054, -3054, - 798, 65677, 58762, 59257, -3054, 682, 1360, 6152, 72041, 30646, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, 413, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, 55297, 64687, 55297, 757, 776, 1072, 786, 32133, - 790, 34609, 794, 825, 1154, 872, 886, 898, 906, 97, - 31142, 787, 638, -3054, 59752, 59752, -57, 197, -3054, 59752, - 60247, -3054, 868, -3054, 950, -3054, -3054, -3054, 1262, -3054, - 135, 926, -3054, 60742, 60742, 60742, 965, 1241, -3054, -3054, - -3054, 958, -3054, -3054, 1197, 20385, 20385, 66172, 66172, 950, - 66172, 997, -3054, -3054, 73, -3054, -3054, -3054, 1561, 980, - 638, -3054, -3054, 52327, -3054, -3054, 294, 1336, 20385, 54802, - 994, -3054, 1051, 994, 1054, 1056, 1061, -3054, 6730, -3054, - 54802, 1414, 1279, 52327, 749, 749, 1533, 749, 622, 628, - 3173, 3454, -3054, 947, -3054, 1076, 1201, 1097, 1416, -3054, - 980, 1472, 905, 1293, 1519, 2639, 1538, 1035, 1544, 1077, - 1552, 1639, 20385, 47377, 638, -3054, 11564, 20385, -3054, -3054, - -3054, 1305, -3054, -3054, -3054, -3054, -3054, 54802, 64687, 1196, - 1222, -3054, -3054, -3054, -3054, 93, 1464, -3054, 1711, -3054, - -3054, 1287, 61237, 61732, 62227, 62722, 66667, 1656, -3054, -3054, - 1610, -3054, -3054, -3054, 1284, -3054, -3054, -3054, 226, 67162, - 1616, 1254, 122, -3054, 1623, 228, -3054, 1629, 1495, 15185, - -3054, 1443, -3054, -3054, -3054, 97, -3054, -3054, -3054, 629, - -3054, -3054, 43244, 72041, 1376, 1292, -3054, 1636, 20385, 20385, - 1296, 3361, 59752, 60247, 20385, 54802, -3054, 20385, 25065, 1298, - 20385, 20385, 12585, 20385, 29656, 59752, 197, 1294, -3054, 586, - 54802, 1299, -3054, 1396, 1396, 731, 31638, 1597, -3054, 880, - 1593, 1520, -3054, 31638, 1520, 1479, 1306, 1598, 1520, -3054, - 299, 1600, 1396, 35104, 1307, -3054, 1396, 1529, -3054, -3054, - 55297, 20385, 15185, 69637, 1783, -3054, -3054, -3054, -3054, 1591, - 64687, 1313, -3054, -3054, -3054, -3054, -3054, -3054, 822, 1823, - 174, 1824, 20385, 174, 174, 1316, 204, 204, -3054, 1508, - 1319, -3054, 210, 1321, 1322, 1832, 1833, 175, 150, 737, - 174, 20385, -3054, 204, 1327, 1837, 1329, 1839, 183, 195, - -3054, 211, 20385, 20385, 20385, 1697, 20385, 10524, 1838, 47377, - -3054, 54802, 709, -3054, 638, 1334, 950, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, 1335, -3054, 185, 7336, -3054, -3054, - -3054, -3054, 1374, -3054, -3054, -3054, -3054, 1554, 20385, -3054, - -3054, 1338, 1597, -3054, 212, -3054, -3054, 1597, -3054, -3054, - -3054, -3054, -3054, 233, 1748, 20385, 20385, 64687, 638, -3054, - 67657, -3054, -3054, -3054, -3054, -3054, -3054, 797, -3054, 413, - 44932, 1339, 1343, 994, 54802, 54802, 1828, -3054, -3054, -3054, - -3054, 1051, 52327, 209, 1644, 1478, -3054, -3054, 1561, 1561, - 15705, 891, 339, 710, 16225, 20905, 1706, 1583, 241, 607, - 1707, -3054, 1594, 1822, 25065, 20385, 20385, 622, 628, 20385, - -3054, -3054, -3054, 1647, 54802, 50347, 745, 837, 1371, 1459, - 1375, 52, 1795, -3054, 1372, -3054, 1470, 54802, 71572, 231, - -3054, 1840, 231, 231, 247, 1851, 1484, 259, 1649, 57, - -51, 2616, -3054, 1372, 52327, 159, 569, 1372, 54802, 1490, - 571, 1372, 1812, 64687, 1292, 41096, 1398, -3054, -3054, -3054, - 163, 15185, -3054, 911, 1117, 1231, 322, 208, 1250, 1272, - 15185, 1304, 1405, 173, 1471, 1488, 1505, 1531, 1540, 1585, - 1599, 1634, 145, 1648, 1671, 1688, 1701, 1703, 1705, -3054, - 1713, 188, 1715, 218, 15185, 1729, -3054, 190, -3054, 44932, - -8, -3054, -3054, 1736, 45021, -3054, 1702, 1496, 1497, 64687, - 1451, 54802, 867, 1555, 1777, 1831, 70117, 54802, 1660, 2616, - 1661, 1423, 1902, 1670, 1222, 1672, 1435, 1678, -3054, 1756, - -3054, 68152, 47377, -3054, -3054, -3054, -3054, -3054, 1807, 1789, - 64687, 47377, 1450, -3054, -3054, 64687, -3054, 54802, 54802, -3054, - 54802, 64687, -3054, 801, 44932, 1956, 117, 72041, 48862, -3054, - -3054, -3054, -3054, 425, 985, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, 950, 47377, -3054, 3660, 55297, 43862, - 1458, 20385, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - 1460, 1805, -3054, -3054, 6524, 1467, 43902, 1469, 25065, 25065, - 638, 1527, -3054, -3054, 25065, 1475, 49357, 43775, 1461, 1476, - 44250, 16745, 20385, 16745, 16745, 44337, -3054, 1477, 44414, 59752, - 1473, 54802, 53812, -3054, -3054, -3054, 20385, 20385, 197, 54307, - 1512, -3054, 31638, -3054, 1754, 31638, -3054, -3054, 1896, -3054, - 31638, 1762, 20385, 31638, -3054, 1721, 1723, 1480, 31638, -3054, - 54802, 1498, 54802, -3054, -3054, -3054, -3054, -3054, 44932, -3054, - 1487, 811, 1500, -3054, -3054, -3054, -3054, -3054, 1557, -3054, - 1557, 1557, -3054, -3054, -3054, -3054, 1509, 1509, 1511, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, 1517, 737, -3054, 1557, -3054, 1509, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, 71572, -3054, -3054, -3054, -3054, - 643, 681, -3054, 1525, -3054, -3054, -3054, -3054, 1528, -3054, - 1501, 1985, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, 6014, 823, 1509, 5103, -3054, -3054, 20385, 20385, -3054, - -3054, 1530, 44932, 1569, -3054, -3054, 20385, 20385, -3054, -3054, - -3054, -3054, 2017, -3054, 20385, 1557, 1557, -3054, 45363, -3054, - 39561, 17265, 1619, 1620, 2017, -3054, 2017, -3054, 45363, 2037, - 2037, 37579, -3054, 1698, 44501, -3054, 1536, 1503, 7998, 1537, - -3054, -3054, 1532, -3054, 1539, 1535, 41759, 164, 638, 638, - 20385, -3054, 2017, 20385, 7141, 7141, -3054, 344, 69637, 20385, - 20385, 20385, 20385, 20385, 20385, 20385, 20385, 45892, 1628, 162, - 64687, 20385, 20385, 1545, 1058, -3054, 20385, 1781, -3054, 1553, - 20385, 1638, 235, 20385, 20385, 20385, 20385, 20385, 20385, 20385, - 20385, 20385, -3054, -3054, 27646, 353, 724, 1889, 1909, 35, - 295, 20385, 1901, 11564, -3054, 1901, -3054, -3054, -3054, -3054, - -3054, 213, -3054, -3054, 1487, 1487, -3054, 64687, -3054, 54802, - 294, 51337, 20385, -3054, -3054, 1562, 1568, 193, -3054, 1630, - -3054, -3054, 54802, 38074, 1869, -3054, 367, 1572, -3054, 43736, - 1830, 1869, 1561, -3054, -3054, 26105, 1708, 1872, 1813, -3054, - -3054, 1794, 1796, -3054, 1589, 45154, 21425, 21425, -3054, 656, - 44932, 1391, -3054, -3054, -3054, -3054, -3054, -3054, 781, -3054, - 54802, 225, 35599, -3054, 1595, 96, -3054, 4021, 1936, 1900, - 1706, 607, 1611, -3054, 1266, 1614, 68647, 54802, 1899, 1858, - 1907, -60, 69637, -3054, -3054, -3054, -3054, 54802, 64687, 63217, - 69142, 47872, 54802, 47377, -3054, -3054, -3054, -3054, 54802, 1094, - 54802, 2790, -3054, -3054, -3054, -3054, 231, -3054, -3054, -3054, - -3054, -3054, 64687, 54802, -3054, -3054, 231, 64687, 54802, 231, - -3054, 1267, 54802, 54802, 54802, 54802, 1295, 54802, 54802, 950, - -3054, -3054, -3054, 21945, 14, 14, 1841, 13105, 121, -3054, - 20385, 20385, 206, 248, 64687, 1801, -3054, -3054, 828, 1848, - 160, -3054, 1673, 54802, 54802, 54802, 54802, 64687, 54802, 1491, - -3054, -3054, -3054, -3054, -3054, 1624, -3054, 1626, 1990, 2616, - -3054, 1991, 50842, 166, 3478, 1997, 1674, 1999, 13625, 2097, - 2000, 2144, 1640, 1879, -3054, -3054, 1867, -3054, 64687, 2157, - -3054, 122, -3054, 47377, -3054, 228, -3054, 1873, 239, -3054, - 15185, 20385, -3054, -3054, -3054, -3054, -3054, -3054, 1292, 28152, - -3054, 832, -3054, -3054, 2121, 950, 2121, 780, -3054, -3054, - 2121, -3054, 2106, 2121, -3054, -3054, 69637, -3054, 8220, -3054, - 20385, 20385, -3054, 20385, 1996, -3054, 2158, 2158, 69637, 25065, - 25065, 25065, 25065, 25065, 25065, 511, 1327, 25065, 25065, 25065, - 25065, 25065, 25065, 25065, 25065, 25065, 26625, 268, -3054, -3054, - 838, 2128, 20385, 20385, 2004, 1996, 20385, -3054, 69637, 1657, - -3054, 1658, 1662, 20385, -3054, 69637, -3054, 54802, 1663, 31, - 27, -3054, 1665, 1666, -3054, 1597, -3054, 856, 935, 54802, - 3395, 5093, 5529, -3054, -3054, 20385, 2001, 1896, 31638, -3054, - 20385, 1669, -3054, -3054, 31638, 2018, -3054, -3054, -3054, 36094, - 1896, 69637, 849, -3054, 54802, 69637, 860, 20385, -3054, 15185, - 2183, 69637, 2148, 64687, 64687, 2186, 1680, 1682, 2017, 1768, - -3054, 1769, 1770, 1771, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, 69637, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, 1675, 1687, 20385, 20385, 85, -3054, 8294, 1686, - 1690, 6447, -3054, 1685, -3054, 1691, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, 1693, -3054, 1700, -3054, 1704, 1716, 1719, - 1728, 1733, 54802, -3054, 22465, -3054, 64687, -3054, -3054, 20385, - 20385, 54802, -3054, 1697, -3054, 1734, 1735, 8386, -3054, -3054, - -3054, 262, 1073, 45260, 295, 45316, 45316, 45316, 45363, -3054, - -3054, -3054, 1726, -3054, 25065, 25065, -3054, 3089, 1200, 10524, - -3054, -3054, 2047, -3054, 1065, -3054, 1717, -3054, -3054, 2724, - -3054, 39561, 7629, 20385, 180, -3054, 20385, 1545, 20385, 1802, - 45316, 45316, 45316, 246, 246, 262, 262, 262, 1073, 295, - -3054, -3054, -3054, 1730, 20385, 47377, -3054, 1737, 1738, 2098, - 1329, 20385, -3054, -3054, 31638, 1512, -8, 1512, 2017, 7141, - -3054, 1051, -3054, -3054, 1051, 44932, 54802, -3054, -3054, 2006, - 1742, 31638, 1785, 2220, 2202, 64687, -3054, -3054, 1744, 1901, - 1760, -3054, -3054, 1765, 20385, 2073, 1765, -3054, 1869, -10, - 1979, 1062, 1062, 656, 1982, -3054, -3054, 1827, -3054, -3054, - -3054, 20385, 14145, 1394, -3054, 1401, -3054, -3054, -3054, -3054, - -3054, 1755, -3054, 2031, -3054, 54802, -3054, -3054, 25065, 2216, - 20385, 36589, 2222, 2019, -3054, -3054, -3054, 1854, 1372, 20385, - 2009, -3054, 156, 1778, 2139, 357, 2091, 64687, -3054, 350, - 459, -3054, 817, 2145, 239, 2147, 239, 47377, 47377, 47377, - 879, -3054, -3054, -3054, 950, -3054, 316, 881, -3054, -3054, - -3054, -3054, 1868, 644, 2616, 1372, -3054, -3054, -3054, -3054, - -3054, -3054, -3054, 184, 690, 1372, 1874, -3054, 1877, -3054, - 1878, 704, 1372, -3054, -3054, 1639, 8960, 44932, 408, 121, - 121, 121, 15185, -3054, 2032, 2033, 1797, 44932, 44932, 153, - -3054, -3054, -3054, -3054, 1786, -3054, 170, -3054, 64687, -3054, - -3054, -3054, 1801, 1831, 54802, 2616, 1803, 2275, 1222, 1435, - 1756, -3054, 1964, 29, 1551, -3054, 64687, 54802, 54802, 54802, - 63712, -3054, -3054, -3054, 1804, 1800, -3054, 20, 2035, 2034, - 54802, 1844, 54802, 1375, 2285, 54802, -3054, 908, 17785, 64687, - -3054, 47377, 2175, 54802, 1789, -3054, -3054, -3054, -3054, 64687, - -3054, -3054, 44932, -3054, -3054, 48367, -3054, -3054, -3054, -3054, - -3054, 47377, -3054, 950, -3054, 950, 2049, 64687, 42254, 950, - 42749, 950, 1814, -3054, 44932, 40064, 44932, 2004, -3054, 155, - 2158, 527, 527, 527, 4897, 2159, 232, 1817, 527, 527, - 527, 146, 146, 155, 155, 155, 2158, 268, 868, 49357, - 1818, -3054, 44932, 44932, -3054, -3054, 1819, -3054, -3054, -3054, - -3054, 1820, 1821, -3054, -3054, -3054, -3054, -3054, -3054, 64687, - 1086, 1512, 417, 417, 417, 417, -3054, 54802, 54802, 54802, - 44932, 2278, 2154, -3054, 1896, 44932, 54802, -3054, 29157, 54802, - -3054, 2174, -3054, 2263, -3054, 54802, 910, -3054, -3054, -3054, - 919, 1834, 1682, 69637, 953, 954, -3054, 2017, 147, 1843, - 1510, 1113, 582, 1402, -3054, -3054, -3054, 1845, 44636, 20385, - -3054, 2204, -3054, -3054, -3054, 20385, 20385, -3054, 39561, -3054, - -3054, -3054, -3054, 372, 372, 1846, 10524, 44858, -3054, 2150, - 40103, 44932, -3054, 1698, -3054, -3054, 7141, 20385, 2351, 3644, - 20385, 1850, 20385, 2184, -3054, -3054, 1849, -3054, -3054, 69637, - 20385, 1860, 4152, 25065, 25065, 4537, -3054, 4675, 20385, 10524, - -3054, 41178, 1852, 1859, 1841, 18305, -3054, 2078, 1861, -3054, - 2001, 121, 2001, 1866, -3054, -3054, -3054, -3054, 5103, -3054, - 20385, 2026, 64687, 371, 1974, 995, -3054, 638, 38074, 1785, - 20385, 244, -3054, -3054, 1880, -3054, 1765, -3054, -3054, -3054, - 2101, -3054, -3054, -3054, 54802, -3054, 1884, -3054, 35599, 2213, - 11044, -3054, 35599, 54802, 54802, 40142, 2248, -3054, 64687, 64687, - 64687, -3054, 64687, 1883, 1887, 850, 1890, 391, -3054, 3681, - 850, 2228, 579, 1375, 259, 2963, 431, -3054, -3054, -3054, - 1966, 54802, -3054, 64687, -3054, -3054, -3054, -3054, -3054, 47872, - -3054, -3054, 39065, 47377, -3054, 47377, 54802, 54802, 54802, 54802, - 54802, 54802, 54802, 54802, 54802, 54802, 1292, 20385, -3054, 20385, - 1893, 1897, 1898, 1841, -3054, -3054, -3054, 237, -3054, 1904, - -3054, -3054, -3054, -51, -3054, 170, 1903, -3054, 50842, 2206, - 1674, 2375, 1910, 1831, 703, 64192, -3054, 1913, 1911, 1008, - 2616, 1916, 2376, -3054, 166, 50842, -3054, -3054, -3054, 2332, - -3054, 682, 220, -3054, 1222, -3054, 2206, 1435, -3054, 2206, - 44932, 1756, 1009, 64687, 1977, -3054, 239, 1013, -3054, -3054, - -3054, -3054, -3054, 64687, 1914, -3054, 1914, -3054, -3054, 1914, - -3054, -3054, -3054, -3054, 25065, 2264, 1924, 69637, -3054, -3054, - 54802, -3054, -3054, -3054, 1014, 1925, 2001, 54802, 54802, 54802, - 54802, -3054, -3054, -3054, 18825, 20385, 1967, -3054, 1930, 12084, - 2241, -3054, 28658, -3054, 214, 1931, 36094, 64687, -3054, -3054, - -3054, -3054, 2017, -3054, -3054, 64687, -3054, 1934, -3054, 1938, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, 20385, - 44932, -3054, 44932, -3054, -3054, -3054, -3054, -3054, 7702, -3054, - 1935, 1939, 64687, 20385, -3054, -3054, -3054, 392, 20385, 20385, - 3089, -3054, 45403, 20385, 69637, 1015, 3089, 354, 20385, 3898, - 4474, 20385, 20385, 5451, 40189, -3054, 22985, 14665, -3054, 1941, - 20385, 40228, 38569, -3054, 31638, 2154, 1948, 2154, 950, 1949, - 44932, 20385, -3054, -3054, -3054, -3054, 1989, 381, 33123, 2176, - -3054, 1963, 64687, -3054, 2026, 44932, -3054, -3054, 39561, -3054, - -3054, -3054, -3054, -3054, 2408, 82, 1953, 1955, -3054, 1328, - -3054, -3054, 64687, 1957, -3054, 1960, 850, -3054, 64687, 2002, - -3054, 258, 2272, 104, -3054, 20385, -3054, 2360, 2439, 3681, - 1968, 64687, 54802, 25065, -3054, 297, 202, -3054, 2255, 54802, - 2002, 2396, -3054, -3054, -3054, 391, -3054, 2295, 2208, -3054, - 231, -3054, 20385, 391, 2210, 238, 64687, -3054, -3054, 2709, - -3054, 69637, 239, 239, -3054, 1500, 1978, 1983, 1987, 1988, - 1994, 1998, 2011, 2015, 2021, 2022, -3054, 2023, 2030, 2038, - 2042, 2044, 2052, 2057, 2061, 1517, 2068, -3054, 2070, 1880, - 2071, 2074, 2077, 2083, 2084, 70597, 2085, 2086, 2087, 2088, - 1525, 2089, 425, 985, -3054, -3054, -3054, -3054, 2092, -3054, - -3054, -3054, 1254, 2003, -3054, -3054, -3054, 2079, -3054, 2090, - -3054, -3054, -3054, -3054, -3054, -3054, 1992, 2076, -3054, -3054, - -3054, 121, 2020, 2050, 64687, 1292, 169, 64687, 2094, 1844, - 2458, 19345, 47377, 764, 2238, 2099, -3054, 950, 1674, -3054, - 50842, 3843, 490, 2034, -3054, 277, 1844, -3054, 2406, 1674, - 2039, 2476, -3054, 2100, -3054, 2245, 64687, 2102, -3054, -3054, - 48367, 1914, 5145, 25065, 69637, 1021, 1037, -3054, 2508, 2240, - 2154, -3054, -3054, -3054, -3054, -3054, 2104, 16, 2115, 10004, - 2093, -3054, -3054, -3054, -3054, -3054, -3054, 44932, 44932, 64687, - 2280, -3054, -3054, 2112, 2105, 37084, 2572, 2117, -3054, 15185, - -3054, 2435, -3054, 30151, -3054, 1682, 2122, 1682, 69637, 1682, - -3054, -3054, 44932, 20385, -3054, -3054, 41217, 2443, 3089, 3089, - 45403, 1060, -3054, 3089, 20385, 20385, 3089, 3089, 20385, -3054, - 9482, 503, -3054, 1066, -3054, 40578, -3054, 71077, -3054, -3054, - 1967, 950, 1967, -3054, -3054, 2118, -3054, -3054, -3054, 2178, - -3054, -3054, 1107, 2547, 2026, 20385, -3054, -3054, 2124, 35599, - -3054, -3054, -3054, -3054, 35599, 850, -3054, 2296, 2002, 2127, - -3054, -3054, -3054, -3054, -3054, -3054, 40664, -3054, 66, 20385, - -3054, 1235, 4897, -3054, -3054, -3054, -3054, 2002, 1222, -3054, - 54802, 2603, 2494, -3054, -3054, 44932, -3054, -3054, 2017, 2017, - -3054, -3054, 2263, -3054, -3054, 2132, -3054, -3054, 1254, -63, - 39065, 54802, 54802, -3054, -3054, 2135, -3054, -3054, -3054, -3054, - -3054, -51, 2534, 1123, 166, -3054, 2206, 2206, 44932, 1148, - 54802, 2507, 50842, -3054, 2620, 2146, 54802, 1844, 1071, 1071, - -3054, 2297, -3054, 2298, -3054, -3054, 2622, 315, -3054, 19865, - 47377, 54802, -3054, -3054, 32628, -3054, 5145, 1152, -3054, -3054, - 2152, 2155, -3054, 1967, 20385, 2160, 20385, -3054, 23505, 2628, - 2162, -3054, 20385, 2218, 27145, -3054, 20385, -3054, 54802, 59752, - 14, 2163, 59752, -3054, -3054, -3054, -3054, -3054, 20385, -3054, - 3089, 3089, 3089, 20385, -3054, 20385, -3054, -3054, -3054, 2364, - 2280, -3054, 2280, 20385, 2206, 638, 1892, 64687, 15, -3054, - 44932, -3054, -3054, -3054, 54802, -3054, 47377, -3054, 850, -9, - 2164, 20385, 40703, 2402, -3054, -3054, 2436, -3054, 2493, -3054, - 2231, 530, 2247, -3054, -3054, -3054, -3054, 1292, 950, 1674, - 2034, 2039, -3054, -3054, 2179, 54802, 2206, 166, 682, -3054, - -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, -3054, - -3054, -3054, 2206, 2614, 2397, 2618, 2206, 44932, 1157, 1977, - 20385, 83, -3054, 1158, 2615, -3054, -3054, 2685, 2280, 2181, - 23505, 2182, -3054, 2189, 64687, 44932, 2330, -3054, -3054, 2194, - -3054, -3054, 121, 20385, -3054, 41267, 2191, 2200, 2655, 1841, - 2218, 2218, -3054, 381, -3054, -3054, 2623, 32628, 2584, 1222, - 850, 2215, 1168, -3054, -3054, -3054, -3054, -3054, 2616, -3054, - 40742, 2449, 223, 2437, 2164, 20385, -3054, 2286, -3054, -3054, - -3054, 2684, -3054, -3054, 50842, 2214, 2039, 2034, 1844, 2039, - 2438, -3054, 2441, -3054, -3054, 2217, 40828, 64687, 64687, 1674, - 32628, 64687, 2212, 2218, -3054, 2219, -3054, -3054, -3054, 53812, - -3054, 2221, 2223, -3054, -3054, -3054, 20385, 187, -3054, -3054, - 2270, 54802, 1177, 43, 2436, 39065, -3054, 47377, 2451, -9, - 2533, -3054, -3054, -3054, -3054, 149, 2452, -3054, 2454, -3054, - 44932, -3054, 2206, 50842, -3054, -3054, -3054, -3054, -3054, -3054, - 32628, 2615, -3054, 367, -3054, 1512, -3054, 367, -3054, -3054, - -3054, -3054, 950, -3054, 1461, 24025, 24025, 24025, 2229, 2206, - -3054, 1512, -3054, 2361, 2437, -3054, -3054, -3054, -3054, -3054, - 165, 165, 2624, -3054, 2299, -3054, 2039, 1179, 64687, 1765, - -3054, 1765, 25585, 2386, 222, 43814, 2604, -3054, 2604, 2604, - -3054, -3054, -3054, 38074, -3054, -3054, 2728, -3054, 217, -3054, - -3054, -3054, 1674, 367, -3054, -3054, 2721, -3054, -3054, -3054, - -3054, -3054, 196, -3054, -3054, -3054, 1512, 850, -3054, -3054, - -3054, 1512, 1765, 24545, 2393, -3054, 2462, -3054, -3054, -3054, - -3054, -3054, -3054, -3054 -}; - -/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. - Performed when YYTABLE does not specify something else to do. Zero + 0, 525, 526, 527, 527, 528, 528, 528, 528, 528, + 528, 528, 528, 528, 528, 528, 528, 528, 528, 528, + 528, 528, 528, 528, 528, 528, 528, 528, 528, 528, + 528, 528, 528, 528, 528, 528, 528, 528, 528, 528, + 528, 528, 528, 528, 528, 528, 529, 529, 529, 529, + 529, 529, 529, 529, 530, 530, 531, 531, 532, 532, + 532, 532, 533, 533, 534, 534, 534, 534, 534, 534, + 534, 534, 534, 534, 534, 534, 534, 534, 534, 534, + 534, 534, 534, 534, 534, 534, 534, 534, 534, 534, + 534, 534, 534, 535, 535, 536, 536, 536, 536, 537, + 537, 538, 539, 539, 539, 540, 540, 540, 540, 541, + 541, 542, 542, 542, 543, 543, 544, 545, 545, 546, + 547, 548, 548, 548, 548, 549, 549, 549, 549, 549, + 549, 549, 549, 549, 549, 549, 549, 549, 550, 550, + 551, 552, 552, 552, 552, 552, 553, 553, 554, 554, + 554, 555, 555, 555, 556, 556, 557, 558, 558, 559, + 559, 559, 560, 560, 560, 561, 561, 561, 562, 562, + 563, 563, 564, 564, 565, 565, 566, 566, 567, 567, + 568, 568, 569, 569, 570, 570, 571, 572, 572, 572, + 573, 573, 574, 574, 575, 575, 575, 576, 576, 576, + 577, 577, 578, 578, 578, 579, 579, 580, 580, 580, + 581, 581, 582, 582, 582, 583, 583, 584, 584, 585, + 585, 586, 586, 587, 587, 588, 588, 588, 589, 589, + 589, 589, 590, 590, 590, 590, 590, 590, 590, 590, + 590, 590, 590, 590, 590, 590, 591, 591, 592, 592, + 592, 593, 593, 594, 594, 595, 595, 595, 595, 595, + 595, 596, 596, 596, 597, 598, 598, 598, 599, 599, + 600, 600, 600, 600, 600, 600, 601, 601, 602, 603, + 603, 603, 603, 603, 604, 604, 604, 604, 605, 605, + 605, 605, 605, 605, 605, 605, 606, 606, 607, 607, + 608, 608, 608, 609, 610, 611, 611, 611, 611, 611, + 612, 612, 612, 612, 613, 614, 614, 615, 615, 616, + 616, 616, 616, 616, 616, 616, 616, 617, 617, 618, + 619, 619, 619, 619, 620, 620, 620, 620, 621, 622, + 622, 622, 623, 624, 624, 624, 624, 624, 624, 625, + 625, 626, 626, 627, 628, 628, 628, 629, 629, 630, + 630, 631, 631, 631, 632, 633, 633, 634, 634, 635, + 636, 636, 636, 636, 637, 637, 638, 638, 639, 639, + 639, 640, 640, 640, 640, 640, 640, 641, 641, 642, + 642, 642, 642, 643, 644, 644, 644, 644, 644, 644, + 644, 644, 645, 645, 646, 646, 646, 646, 646, 646, + 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, + 647, 647, 647, 647, 647, 647, 647, 647, 648, 648, + 648, 648, 648, 648, 649, 649, 650, 650, 650, 651, + 651, 651, 652, 652, 652, 652, 652, 652, 653, 653, + 654, 654, 655, 656, 656, 656, 657, 657, 657, 658, + 658, 659, 659, 660, 660, 661, 661, 662, 662, 663, + 663, 664, 664, 665, 665, 665, 665, 665, 665, 666, + 667, 667, 668, 668, 669, 669, 670, 670, 670, 670, + 670, 670, 670, 670, 670, 670, 670, 670, 670, 670, + 670, 670, 671, 672, 672, 672, 672, 672, 673, 673, + 674, 674, 675, 675, 675, 676, 676, 676, 676, 676, + 676, 676, 676, 677, 677, 678, 678, 679, 679, 679, + 679, 679, 679, 679, 679, 679, 679, 679, 679, 679, + 679, 679, 679, 679, 679, 679, 680, 680, 681, 681, + 682, 682, 683, 683, 683, 684, 684, 685, 685, 686, + 686, 686, 687, 687, 688, 689, 689, 689, 690, 690, + 691, 691, 691, 691, 691, 691, 691, 691, 691, 692, + 692, 693, 693, 693, 694, 695, 695, 696, 696, 697, + 697, 697, 698, 698, 699, 699, 700, 700, 701, 701, + 702, 702, 702, 703, 703, 703, 704, 704, 704, 704, + 705, 705, 706, 706, 706, 706, 707, 707, 708, 708, + 708, 708, 708, 708, 709, 709, 710, 710, 711, 711, + 711, 711, 712, 713, 713, 714, 714, 715, 715, 715, + 715, 715, 716, 717, 717, 717, 718, 718, 719, 719, + 720, 720, 721, 721, 721, 722, 722, 723, 723, 724, + 724, 724, 724, 724, 725, 726, 727, 728, 729, 729, + 730, 730, 731, 731, 732, 732, 733, 733, 734, 734, + 735, 736, 736, 736, 736, 737, 737, 738, 738, 738, + 739, 739, 740, 740, 741, 741, 742, 742, 743, 743, + 744, 744, 744, 744, 744, 744, 744, 744, 744, 744, + 745, 745, 746, 746, 746, 747, 747, 748, 748, 748, + 748, 749, 749, 750, 750, 751, 751, 752, 753, 753, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 755, 755, 755, 755, 756, 756, 757, 757, 757, + 757, 757, 758, 758, 758, 758, 758, 758, 759, 759, + 760, 760, 761, 761, 761, 761, 762, 762, 763, 764, + 764, 765, 765, 766, 766, 767, 767, 768, 768, 769, + 770, 770, 771, 771, 772, 772, 773, 773, 774, 774, + 774, 774, 774, 774, 774, 774, 774, 774, 775, 775, + 776, 776, 776, 777, 777, 777, 777, 777, 777, 777, + 778, 778, 778, 778, 779, 780, 780, 781, 781, 781, + 781, 781, 781, 781, 781, 781, 781, 781, 782, 782, + 783, 783, 784, 784, 785, 786, 787, 787, 788, 788, + 789, 790, 791, 791, 791, 791, 791, 791, 792, 792, + 793, 793, 793, 793, 794, 795, 795, 795, 796, 796, + 797, 797, 798, 798, 799, 799, 800, 800, 801, 801, + 802, 802, 803, 803, 804, 804, 805, 805, 806, 806, + 807, 807, 808, 808, 808, 808, 808, 808, 808, 808, + 808, 808, 808, 808, 808, 808, 808, 808, 808, 808, + 808, 808, 809, 809, 809, 809, 809, 809, 809, 809, + 809, 809, 809, 809, 809, 809, 809, 809, 809, 809, + 809, 809, 809, 809, 809, 809, 809, 809, 809, 809, + 809, 809, 809, 809, 809, 809, 809, 809, 809, 809, + 809, 809, 809, 809, 809, 809, 809, 809, 809, 809, + 809, 809, 809, 809, 809, 809, 809, 809, 809, 809, + 809, 809, 809, 809, 809, 809, 809, 809, 809, 809, + 809, 809, 810, 810, 810, 810, 810, 810, 810, 810, + 810, 810, 810, 810, 810, 810, 810, 810, 810, 810, + 810, 810, 810, 810, 810, 810, 810, 811, 811, 812, + 812, 812, 812, 812, 812, 813, 813, 813, 814, 814, + 814, 814, 814, 814, 814, 814, 814, 814, 814, 814, + 815, 816, 816, 816, 816, 816, 816, 817, 817, 818, + 818, 819, 819, 819, 819, 819, 819, 819, 819, 819, + 819, 819, 819, 819, 819, 820, 820, 821, 821, 822, + 822, 822, 823, 823, 824, 824, 825, 825, 826, 827, + 827, 827, 828, 829, 829, 830, 830, 831, 831, 831, + 831, 832, 832, 833, 833, 833, 833, 833, 834, 834, + 834, 834, 834, 835, 835, 836, 836, 837, 838, 838, + 839, 839, 840, 841, 841, 842, 842, 843, 843, 844, + 844, 844, 845, 845, 846, 846, 846, 846, 846, 846, + 846, 846, 846, 846, 846, 846, 846, 846, 847, 847, + 848, 848, 849, 849, 849, 849, 849, 849, 849, 849, + 850, 850, 851, 851, 852, 852, 853, 853, 854, 854, + 855, 855, 856, 856, 857, 857, 857, 858, 858, 859, + 859, 860, 860, 860, 860, 860, 860, 860, 860, 860, + 860, 860, 860, 860, 860, 861, 861, 862, 863, 863, + 864, 864, 864, 864, 864, 864, 865, 866, 867, 867, + 867, 868, 868, 869, 870, 870, 871, 872, 872, 873, + 873, 874, 874, 546, 546, 546, 546, 875, 875, 876, + 876, 877, 877, 877, 878, 878, 878, 878, 878, 879, + 879, 880, 880, 881, 881, 882, 882, 883, 883, 884, + 884, 884, 885, 885, 886, 886, 887, 888, 888, 889, + 889, 890, 890, 890, 891, 891, 892, 892, 893, 893, + 894, 894, 895, 896, 896, 897, 897, 897, 897, 897, + 897, 897, 897, 897, 897, 897, 897, 897, 897, 898, + 899, 899, 899, 900, 900, 900, 901, 901, 901, 902, + 902, 903, 903, 904, 904, 905, 906, 906, 907, 908, + 908, 909, 909, 909, 909, 909, 909, 910, 910, 910, + 911, 911, 912, 912, 912, 912, 913, 913, 914, 915, + 915, 916, 916, 917, 917, 918, 918, 919, 919, 920, + 920, 920, 920, 920, 920, 921, 921, 922, 922, 923, + 923, 924, 924, 925, 925, 925, 925, 925, 925, 925, + 925, 925, 925, 926, 926, 927, 928, 928, 928, 928, + 929, 929, 930, 930, 930, 931, 931, 931, 931, 931, + 931, 931, 931, 931, 931, 931, 931, 931, 931, 931, + 931, 931, 931, 931, 931, 931, 931, 931, 931, 931, + 931, 931, 931, 931, 931, 932, 932, 932, 933, 933, + 934, 934, 935, 935, 936, 936, 936, 936, 937, 938, + 938, 939, 939, 939, 939, 940, 940, 940, 940, 941, + 941, 942, 943, 943, 943, 943, 943, 943, 943, 944, + 944, 945, 945, 945, 945, 945, 946, 946, 947, 947, + 948, 948, 948, 948, 948, 949, 949, 949, 949, 949, + 950, 950, 951, 951, 952, 952, 953, 953, 954, 954, + 954, 955, 955, 956, 956, 957, 957, 958, 958, 959, + 959, 959, 960, 960, 961, 961, 962, 962, 962, 962, + 963, 963, 964, 964, 964, 965, 965, 965, 965, 965, + 965, 965, 965, 966, 966, 967, 967, 968, 968, 969, + 969, 970, 970, 971, 972, 972, 972, 972, 972, 973, + 973, 973, 973, 974, 974, 974, 975, 975, 975, 976, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, + 978, 978, 978, 978, 978, 978, 978, 978, 978, 978, + 978, 978, 978, 978, 978, 978, 978, 978, 978, 978, + 978, 978, 978, 978, 978, 978, 978, 978, 978, 978, + 978, 978, 978, 978, 978, 978, 978, 978, 978, 978, + 978, 978, 978, 978, 978, 978, 978, 978, 978, 978, + 978, 978, 978, 978, 979, 979, 979, 979, 979, 979, + 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, + 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, + 979, 979, 980, 980, 980, 980, 980, 980, 980, 980, + 980, 980, 980, 980, 980, 980, 980, 980, 980, 980, + 980, 980, 980, 980, 980, 980, 980, 980, 980, 980, + 980, 981, 981, 981, 981, 981, 981, 981, 981, 981, + 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, + 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, + 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, + 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, + 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, + 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, + 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, + 981, 981, 982, 982, 982, 982, 982, 982, 982, 982, + 982, 982, 982, 982, 982, 982, 982, 982, 982, 982, + 982, 982, 982, 982, 982, 982, 982, 982, 982, 982, + 982, 982, 982, 982, 983, 983, 983, 983, 983, 983, + 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, + 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, + 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, + 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, + 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, + 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, + 983, 983, 983, 983, 983, 983, 983, 983, 983 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 1, 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, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 0, 4, 6, 4, 6, + 4, 6, 4, 6, 1, 2, 3, 2, 1, 3, + 2, 3, 1, 3, 2, 5, 3, 6, 4, 6, + 6, 6, 5, 5, 6, 9, 4, 5, 7, 6, + 4, 8, 4, 2, 4, 3, 6, 4, 2, 2, + 2, 2, 1, 2, 0, 1, 2, 2, 2, 1, + 3, 4, 2, 1, 0, 2, 3, 2, 3, 1, + 2, 1, 1, 1, 1, 1, 1, 1, 2, 2, + 1, 1, 1, 1, 1, 6, 6, 8, 6, 8, + 6, 8, 6, 8, 8, 10, 8, 10, 1, 0, + 9, 1, 4, 4, 7, 2, 1, 3, 2, 2, + 0, 4, 3, 0, 1, 0, 2, 3, 5, 2, + 2, 0, 8, 5, 0, 5, 5, 7, 2, 0, + 1, 1, 1, 3, 2, 0, 1, 0, 1, 3, + 1, 3, 1, 2, 1, 3, 2, 6, 8, 5, + 1, 0, 1, 3, 2, 4, 5, 5, 8, 7, + 1, 0, 8, 11, 10, 0, 1, 0, 1, 1, + 0, 2, 3, 9, 12, 1, 3, 1, 3, 3, + 0, 4, 6, 1, 2, 1, 1, 0, 1, 2, + 2, 1, 2, 2, 1, 2, 3, 2, 2, 2, + 2, 3, 3, 3, 1, 3, 1, 0, 1, 2, + 2, 5, 7, 0, 2, 2, 2, 2, 2, 2, + 2, 1, 1, 0, 2, 9, 12, 11, 0, 2, + 1, 1, 1, 1, 1, 1, 3, 0, 1, 2, + 1, 1, 2, 2, 3, 1, 1, 2, 2, 1, + 2, 3, 5, 3, 2, 5, 1, 1, 1, 0, + 5, 7, 5, 2, 3, 1, 1, 2, 2, 0, + 3, 4, 4, 0, 3, 2, 0, 3, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, + 1, 2, 2, 2, 2, 2, 2, 0, 3, 3, + 3, 0, 1, 2, 1, 2, 2, 2, 2, 3, + 4, 1, 3, 1, 1, 1, 1, 3, 1, 2, + 0, 1, 2, 0, 1, 3, 0, 2, 0, 3, + 3, 1, 5, 3, 1, 3, 1, 2, 1, 4, + 5, 5, 6, 3, 7, 4, 11, 1, 3, 2, + 2, 2, 0, 3, 1, 1, 2, 2, 2, 2, + 1, 0, 1, 2, 6, 4, 6, 4, 6, 8, + 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, + 1, 1, 1, 3, 3, 3, 3, 1, 2, 2, + 1, 3, 1, 1, 1, 3, 1, 1, 0, 1, + 1, 1, 8, 11, 10, 7, 10, 9, 1, 1, + 2, 3, 8, 11, 9, 7, 0, 3, 3, 1, + 1, 3, 0, 1, 3, 1, 0, 1, 0, 1, + 0, 1, 3, 1, 1, 1, 3, 1, 0, 2, + 2, 0, 2, 0, 1, 0, 1, 1, 1, 3, + 3, 1, 1, 3, 3, 3, 3, 3, 3, 4, + 3, 2, 1, 1, 1, 1, 3, 1, 1, 3, + 1, 1, 3, 3, 3, 1, 2, 4, 4, 2, + 3, 5, 5, 1, 1, 3, 0, 11, 11, 10, + 12, 1, 2, 5, 4, 4, 4, 4, 7, 5, + 4, 7, 6, 9, 9, 4, 1, 1, 1, 1, + 1, 1, 1, 5, 1, 1, 3, 1, 2, 2, + 2, 3, 1, 3, 7, 1, 2, 0, 2, 0, + 3, 3, 4, 4, 4, 4, 3, 2, 1, 1, + 0, 1, 1, 0, 2, 1, 5, 1, 0, 2, + 2, 0, 1, 0, 3, 5, 1, 3, 4, 3, + 1, 1, 0, 2, 2, 0, 2, 2, 1, 1, + 1, 0, 2, 4, 5, 4, 2, 3, 2, 2, + 2, 2, 1, 2, 3, 0, 1, 0, 5, 1, + 4, 6, 2, 1, 0, 4, 0, 1, 1, 2, + 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, + 1, 1, 3, 3, 0, 1, 3, 1, 2, 1, + 1, 1, 1, 1, 2, 4, 4, 5, 1, 1, + 2, 0, 2, 0, 1, 3, 1, 0, 1, 2, + 3, 2, 4, 2, 3, 2, 0, 1, 2, 0, + 4, 5, 1, 2, 2, 0, 1, 3, 1, 2, + 3, 3, 3, 3, 3, 3, 1, 4, 9, 9, + 3, 0, 2, 2, 0, 5, 3, 0, 1, 1, + 3, 5, 3, 1, 2, 1, 3, 5, 1, 2, + 3, 4, 5, 4, 5, 4, 6, 5, 4, 5, + 5, 5, 2, 4, 1, 1, 0, 1, 4, 5, + 4, 0, 2, 2, 2, 1, 1, 1, 1, 0, + 4, 2, 1, 2, 2, 4, 2, 6, 2, 1, + 3, 4, 0, 2, 0, 2, 0, 1, 3, 3, + 2, 0, 2, 4, 1, 1, 1, 0, 2, 3, + 5, 6, 2, 3, 1, 5, 5, 5, 3, 3, + 3, 4, 0, 1, 1, 1, 1, 1, 2, 4, + 1, 1, 1, 1, 2, 3, 0, 1, 1, 1, + 1, 1, 2, 2, 2, 2, 2, 1, 3, 0, + 1, 1, 1, 1, 5, 2, 1, 1, 1, 1, + 4, 1, 2, 2, 1, 3, 3, 2, 1, 0, + 5, 2, 5, 2, 1, 3, 3, 0, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, + 3, 0, 1, 3, 3, 5, 2, 2, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 2, 2, 3, 3, 2, 2, 3, + 3, 5, 4, 6, 3, 5, 4, 6, 4, 6, + 5, 7, 3, 2, 4, 3, 2, 3, 3, 3, + 3, 4, 3, 4, 3, 4, 5, 6, 6, 7, + 6, 7, 6, 7, 3, 4, 4, 6, 1, 4, + 3, 5, 1, 3, 2, 2, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 2, 2, 5, 6, 6, 7, 1, 2, 1, + 1, 1, 2, 2, 4, 3, 1, 1, 1, 1, + 1, 4, 1, 1, 3, 1, 2, 4, 2, 2, + 3, 3, 6, 7, 9, 7, 7, 5, 1, 1, + 1, 5, 6, 6, 4, 4, 4, 4, 6, 5, + 5, 5, 4, 6, 4, 7, 9, 5, 0, 5, + 4, 0, 1, 0, 2, 0, 1, 3, 3, 2, + 2, 0, 6, 1, 0, 3, 0, 3, 3, 3, + 0, 1, 4, 2, 2, 2, 2, 2, 3, 2, + 2, 3, 0, 4, 3, 1, 5, 3, 1, 3, + 1, 2, 3, 1, 3, 1, 2, 1, 0, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, + 1, 4, 1, 4, 1, 2, 1, 2, 1, 2, + 1, 3, 1, 3, 1, 2, 1, 3, 1, 2, + 1, 0, 1, 3, 1, 3, 3, 1, 3, 3, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 4, 3, 2, 3, 0, + 3, 3, 2, 2, 1, 0, 2, 2, 3, 2, + 1, 1, 3, 5, 1, 2, 4, 2, 0, 1, + 0, 1, 2, 3, 5, 7, 7, 1, 0, 0, + 2, 0, 2, 3, 3, 3, 5, 7, 7, 0, + 2, 1, 0, 1, 0, 1, 3, 1, 2, 3, + 2, 1, 4, 2, 1, 0, 3, 1, 3, 1, + 2, 4, 2, 0, 1, 3, 1, 3, 1, 2, + 1, 3, 1, 1, 2, 1, 1, 2, 1, 1, + 2, 7, 2, 5, 3, 3, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 2, 3, 3, 0, 1, 1, 1, 5, 3, + 0, 1, 1, 1, 1, 1, 1, 4, 7, 6, + 2, 0, 1, 1, 1, 1, 13, 16, 1, 2, + 0, 1, 0, 1, 0, 2, 0, 1, 0, 6, + 8, 6, 8, 6, 8, 3, 2, 1, 0, 6, + 6, 1, 1, 1, 1, 1, 1, 2, 1, 1, + 1, 1, 1, 4, 6, 3, 2, 4, 3, 5, + 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 3, 1, 1, 1, 1, 1, 1, 2, 1, + 1, 2, 3, 3, 3, 1, 3, 3, 2, 3, + 3, 1, 1, 1, 3, 5, 1, 1, 1, 1, + 3, 2, 2, 3, 4, 5, 1, 1, 1, 1, + 4, 6, 5, 4, 6, 1, 1, 1, 1, 1, + 1, 0, 1, 3, 1, 0, 7, 3, 1, 2, + 3, 2, 0, 2, 0, 2, 4, 5, 8, 2, + 3, 5, 1, 0, 2, 0, 2, 3, 3, 3, + 1, 1, 1, 2, 3, 2, 2, 2, 2, 3, + 4, 3, 1, 1, 1, 1, 1, 1, 0, 1, + 3, 1, 3, 2, 9, 12, 11, 12, 14, 3, + 4, 4, 0, 7, 10, 9, 2, 3, 0, 4, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero means the default is an error. */ -static const yytype_int16 yydefact[] = +static const yytype_uint16 yydefact[] = { - 155, 263, 0, 1380, 1379, 1450, 263, 0, 1315, 0, - 263, 485, 401, 0, 1471, 1470, 0, 207, 263, 0, + 155, 263, 0, 1383, 1382, 1453, 263, 0, 1318, 0, + 263, 485, 401, 0, 1474, 1473, 0, 207, 263, 0, 155, 0, 0, 0, 0, 0, 0, 548, 551, 549, - 0, 0, 0, 263, 588, 0, 1472, 263, 0, 0, - 580, 550, 0, 1428, 0, 0, 0, 0, 0, 2, - 4, 5, 6, 7, 8, 9, 23, 10, 11, 12, - 13, 19, 14, 15, 16, 17, 18, 20, 21, 22, - 25, 24, 26, 27, 1338, 28, 29, 30, 31, 0, - 32, 33, 34, 35, 36, 524, 510, 593, 523, 0, - 0, 154, 692, 531, 37, 38, 39, 40, 41, 42, - 43, 1473, 1469, 44, 262, 261, 255, 0, 0, 0, - 0, 0, 1449, 0, 0, 256, 111, 1497, 1498, 1499, - 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1871, 1508, - 1509, 1510, 1511, 1512, 1872, 1513, 1514, 1515, 1817, 1818, - 1873, 1819, 1820, 1516, 1517, 1518, 1519, 1520, 1521, 1522, - 1523, 1524, 1525, 1821, 1822, 1526, 1527, 1528, 1529, 1530, - 1823, 1874, 1824, 1531, 1532, 1533, 1534, 1535, 1875, 1536, - 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1876, 1545, - 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1825, - 1555, 1556, 1826, 1557, 1558, 1559, 1560, 1561, 1562, 1563, - 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, - 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, - 1827, 1584, 1585, 1586, 1587, 1588, 1828, 1589, 1590, 1591, - 1829, 1592, 1593, 1594, 1877, 1878, 1595, 1596, 1830, 1880, - 1597, 1598, 1831, 1832, 1599, 1600, 1601, 1602, 1603, 1604, - 1605, 1606, 1607, 1881, 1608, 1609, 1610, 1611, 1612, 1613, - 1614, 1615, 1616, 1617, 1618, 1619, 1882, 1833, 1620, 1621, - 1622, 1623, 1624, 1834, 1835, 1836, 1625, 1883, 1884, 1626, - 1885, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1886, 1634, - 1887, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1837, - 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, - 1653, 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, - 1838, 1889, 1839, 1663, 1664, 1665, 1840, 1666, 1667, 1890, - 1668, 1841, 1669, 1842, 1670, 1671, 1672, 1673, 1674, 1675, - 1676, 1677, 1678, 1679, 1843, 1891, 1680, 1892, 1844, 1681, - 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 1690, 1691, - 1692, 1693, 1845, 1893, 1694, 1695, 1846, 1696, 1697, 1698, - 1699, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, 1847, - 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, - 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1894, - 1727, 1728, 1729, 1848, 1730, 1731, 1732, 1733, 1734, 1735, - 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, - 1746, 1747, 1748, 1849, 1749, 1750, 1895, 1751, 1752, 1850, - 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, - 1763, 1764, 1765, 1851, 1766, 1852, 1767, 1768, 1769, 1897, - 1770, 1771, 1772, 1773, 1774, 1775, 1853, 1854, 1776, 1777, - 1855, 1778, 1856, 1779, 1780, 1857, 1781, 1782, 1783, 1784, - 1785, 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, - 1795, 1796, 1797, 1858, 1859, 1798, 1898, 1799, 1800, 1801, - 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, - 1812, 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1867, 1868, - 1869, 1870, 1813, 1814, 1815, 1816, 0, 112, 113, 1262, - 1480, 0, 1240, 111, 1830, 1837, 1851, 1313, 1314, 112, + 0, 0, 0, 263, 588, 0, 1475, 263, 0, 0, + 580, 550, 0, 1431, 0, 0, 0, 0, 0, 2, + 4, 7, 21, 35, 31, 0, 20, 33, 18, 17, + 26, 6, 24, 37, 39, 19, 25, 15, 38, 13, + 36, 524, 510, 593, 523, 0, 0, 154, 692, 531, + 34, 16, 30, 5, 11, 12, 28, 29, 27, 1341, + 42, 32, 40, 22, 8, 9, 23, 41, 43, 1476, + 1472, 10, 44, 14, 262, 261, 255, 0, 0, 0, + 0, 0, 1452, 0, 0, 256, 111, 1500, 1501, 1502, + 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1874, 1511, + 1512, 1513, 1514, 1515, 1875, 1516, 1517, 1518, 1820, 1821, + 1876, 1822, 1823, 1519, 1520, 1521, 1522, 1523, 1524, 1525, + 1526, 1527, 1528, 1824, 1825, 1529, 1530, 1531, 1532, 1533, + 1826, 1877, 1827, 1534, 1535, 1536, 1537, 1538, 1878, 1539, + 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547, 1879, 1548, + 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1828, + 1558, 1559, 1829, 1560, 1561, 1562, 1563, 1564, 1565, 1566, + 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, + 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, + 1830, 1587, 1588, 1589, 1590, 1591, 1831, 1592, 1593, 1594, + 1832, 1595, 1596, 1597, 1880, 1881, 1598, 1599, 1833, 1883, + 1600, 1601, 1834, 1835, 1602, 1603, 1604, 1605, 1606, 1607, + 1608, 1609, 1610, 1884, 1611, 1612, 1613, 1614, 1615, 1616, + 1617, 1618, 1619, 1620, 1621, 1622, 1885, 1836, 1623, 1624, + 1625, 1626, 1627, 1837, 1838, 1839, 1628, 1886, 1887, 1629, + 1888, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1889, 1637, + 1890, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1840, + 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, + 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, + 1841, 1892, 1842, 1666, 1667, 1668, 1843, 1669, 1670, 1893, + 1671, 1844, 1672, 1845, 1673, 1674, 1675, 1676, 1677, 1678, + 1679, 1680, 1681, 1682, 1846, 1894, 1683, 1895, 1847, 1684, + 1685, 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, + 1695, 1696, 1848, 1896, 1697, 1698, 1849, 1699, 1700, 1701, + 1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1850, + 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, + 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1897, + 1730, 1731, 1732, 1851, 1733, 1734, 1735, 1736, 1737, 1738, + 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, + 1749, 1750, 1751, 1852, 1752, 1753, 1898, 1754, 1755, 1853, + 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, + 1766, 1767, 1768, 1854, 1769, 1855, 1770, 1771, 1772, 1900, + 1773, 1774, 1775, 1776, 1777, 1778, 1856, 1857, 1779, 1780, + 1858, 1781, 1859, 1782, 1783, 1860, 1784, 1785, 1786, 1787, + 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, + 1798, 1799, 1800, 1861, 1862, 1801, 1901, 1802, 1803, 1804, + 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, + 1815, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, + 1872, 1873, 1816, 1817, 1818, 1819, 0, 1483, 0, 1243, + 112, 113, 1265, 111, 1833, 1840, 1854, 1317, 1316, 112, 0, 258, 484, 0, 0, 0, 0, 0, 0, 209, - 0, 395, 394, 0, 1304, 400, 0, 0, 0, 115, - 107, 1696, 114, 1239, 105, 121, 2041, 2042, 2043, 2044, - 1928, 2045, 2046, 2047, 2048, 1929, 2049, 1930, 1931, 1932, - 1933, 1934, 1935, 2050, 2051, 2052, 1937, 1936, 2053, 1938, - 2054, 1939, 2055, 1940, 1941, 2056, 2057, 1942, 1551, 1943, - 1944, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, - 1945, 1946, 2067, 2068, 1947, 2069, 2070, 1948, 2071, 1949, - 1950, 1951, 2072, 2073, 1952, 1953, 2074, 1954, 2075, 2076, - 1955, 1956, 1959, 1957, 2077, 1958, 2078, 1960, 1961, 1962, - 2079, 2080, 1963, 1964, 2081, 1965, 1966, 1967, 1968, 1969, - 2082, 1970, 2083, 1971, 1972, 2084, 2085, 2086, 2087, 2088, - 1974, 1973, 1975, 1976, 2089, 2090, 2091, 2092, 1977, 1978, - 1979, 2093, 2094, 1980, 2095, 2096, 1981, 1982, 2097, 1983, - 1984, 2098, 1985, 1986, 2099, 1987, 1988, 2100, 2101, 2102, - 1989, 2103, 1990, 1991, 2104, 2105, 1992, 1993, 2106, 1994, - 2107, 2108, 2109, 2110, 1995, 1996, 2111, 1997, 2112, 2113, - 2114, 2115, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, - 2006, 2007, 2008, 1446, 123, 122, 124, 0, 419, 420, + 0, 395, 394, 0, 1307, 400, 0, 0, 0, 115, + 107, 1699, 114, 1242, 105, 121, 2044, 2045, 2046, 2047, + 1931, 2048, 2049, 2050, 2051, 1932, 2052, 1933, 1934, 1935, + 1936, 1937, 1938, 2053, 2054, 2055, 1940, 1939, 2056, 1941, + 2057, 1942, 2058, 1943, 1944, 2059, 2060, 1945, 1554, 1946, + 1947, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, + 1948, 1949, 2070, 2071, 1950, 2072, 2073, 1951, 2074, 1952, + 1953, 1954, 2075, 2076, 1955, 1956, 2077, 1957, 2078, 2079, + 1958, 1959, 1962, 1960, 2080, 1961, 2081, 1963, 1964, 1965, + 2082, 2083, 1966, 1967, 2084, 1968, 1969, 1970, 1971, 1972, + 2085, 1973, 2086, 1974, 1975, 2087, 2088, 2089, 2090, 2091, + 1977, 1976, 1978, 1979, 2092, 2093, 2094, 2095, 1980, 1981, + 1982, 2096, 2097, 1983, 2098, 2099, 1984, 1985, 2100, 1986, + 1987, 2101, 1988, 1989, 2102, 1990, 1991, 2103, 2104, 2105, + 1992, 2106, 1993, 1994, 2107, 2108, 1995, 1996, 2109, 1997, + 2110, 2111, 2112, 2113, 1998, 1999, 2114, 2000, 2115, 2116, + 2117, 2118, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, + 2009, 2010, 2011, 1449, 123, 122, 124, 0, 419, 420, 0, 430, 0, 412, 417, 413, 0, 439, 432, 440, 421, 411, 433, 422, 410, 208, 0, 441, 427, 415, 0, 0, 0, 0, 259, 220, 401, 0, 155, 0, - 1342, 1343, 1344, 1345, 1346, 1347, 1352, 1348, 1349, 1350, - 1351, 1353, 1354, 1355, 1356, 1357, 1333, 1338, 1358, 1359, - 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, - 1370, 1371, 0, 1315, 0, 0, 1823, 1874, 1828, 0, - 1841, 0, 1844, 1845, 1730, 1852, 1855, 1856, 1857, 1858, - 0, 760, 114, 109, 744, 0, 526, 696, 706, 744, - 749, 1026, 772, 1027, 0, 116, 1414, 1413, 1409, 1408, - 194, 1277, 1458, 1597, 1637, 1747, 1853, 1776, 1476, 1459, - 1453, 1457, 260, 587, 585, 0, 1211, 1597, 1637, 1734, - 1747, 1853, 1388, 1392, 0, 257, 1478, 1463, 0, 1464, - 114, 532, 579, 0, 264, 1427, 0, 1432, 0, 1710, - 559, 562, 1271, 560, 524, 0, 0, 1, 155, 1337, - 1442, 0, 161, 0, 583, 583, 0, 583, 0, 516, - 0, 0, 524, 519, 523, 693, 1475, 1853, 1776, 1462, - 1465, 1606, 0, 0, 1606, 0, 1606, 0, 1606, 0, - 0, 1452, 1195, 0, 1241, 117, 0, 0, 1326, 1322, - 1327, 1323, 1328, 1321, 1320, 1329, 1325, 0, 0, 0, - 366, 399, 398, 397, 396, 401, 1606, 1288, 0, 448, - 449, 0, 0, 0, 0, 0, 205, 1299, 108, 106, - 1606, 1447, 428, 429, 0, 418, 414, 416, 0, 0, - 1606, 1266, 438, 434, 1606, 438, 1233, 1606, 0, 0, - 212, 0, 394, 1335, 1372, 1995, 1373, 1374, 1386, 0, - 1387, 1377, 1341, 155, 0, 483, 1312, 1410, 0, 0, - 0, 1147, 744, 749, 0, 0, 762, 0, 1166, 0, - 1172, 0, 0, 0, 744, 531, 0, 706, 761, 110, - 0, 742, 743, 634, 634, 588, 0, 569, 754, 0, - 0, 757, 755, 0, 757, 0, 0, 0, 757, 753, - 714, 0, 634, 0, 742, 745, 634, 0, 764, 1332, - 0, 0, 0, 0, 0, 1456, 1454, 1455, 1460, 0, - 0, 0, 1243, 1245, 1246, 1115, 1256, 1012, 0, 1818, - 1819, 1820, 1187, 1821, 1822, 1824, 1825, 1826, 966, 1571, - 1827, 1254, 1829, 1831, 1832, 1834, 1835, 1836, 1837, 1838, - 1839, 0, 1255, 1842, 1675, 1847, 1848, 1850, 1853, 1854, - 1253, 1859, 0, 0, 0, 1222, 1138, 0, 0, 0, - 1011, 0, 1188, 1196, 1007, 0, 0, 808, 809, 830, - 831, 810, 836, 837, 839, 811, 0, 1218, 900, 995, - 1206, 1014, 1045, 1016, 1025, 1003, 1082, 996, 0, 1006, - 998, 1214, 569, 1212, 0, 999, 1242, 569, 1210, 1391, - 1389, 1395, 1390, 0, 0, 0, 0, 0, 110, 1434, - 1435, 1426, 1424, 1425, 1423, 1422, 1429, 0, 1431, 1338, - 1133, 1135, 0, 561, 0, 0, 0, 513, 512, 514, - 3, 1271, 0, 0, 0, 0, 581, 582, 0, 0, + 1347, 1357, 1366, 1362, 1356, 1364, 1354, 1360, 1346, 1368, + 1355, 1359, 1352, 1369, 1350, 1367, 1365, 1353, 1361, 1345, + 1349, 1336, 1341, 1372, 1363, 1370, 1358, 1371, 1373, 1348, + 1374, 1351, 0, 1318, 0, 0, 1826, 1877, 1831, 0, + 1844, 0, 1847, 1848, 1733, 1855, 1858, 1859, 1860, 1861, + 0, 762, 114, 109, 746, 0, 526, 696, 706, 746, + 751, 1029, 774, 1030, 0, 116, 1417, 1416, 1412, 1411, + 194, 1280, 1461, 1600, 1640, 1750, 1856, 1779, 1479, 1462, + 1456, 1460, 260, 587, 585, 0, 1214, 1600, 1640, 1737, + 1750, 1856, 1391, 1395, 0, 257, 1481, 1466, 0, 1467, + 114, 532, 579, 0, 264, 1430, 0, 1435, 0, 1713, + 559, 562, 1274, 560, 524, 0, 0, 1, 155, 0, + 161, 0, 583, 583, 0, 583, 0, 516, 0, 0, + 524, 519, 523, 693, 1340, 1445, 1478, 1856, 1779, 1465, + 1468, 1609, 0, 0, 1609, 0, 1609, 0, 1609, 0, + 0, 1455, 1198, 0, 1244, 117, 0, 0, 1329, 1325, + 1330, 1326, 1331, 1324, 1323, 1332, 1328, 0, 0, 0, + 366, 399, 398, 397, 396, 401, 1609, 1291, 0, 205, + 448, 449, 0, 0, 0, 0, 0, 1302, 108, 106, + 1609, 1450, 428, 429, 0, 418, 414, 416, 0, 0, + 1609, 1269, 438, 434, 1609, 438, 1236, 1609, 0, 0, + 212, 0, 394, 1338, 1375, 1998, 1389, 0, 1390, 1380, + 1344, 1376, 1377, 155, 0, 483, 1315, 1413, 0, 0, + 0, 1150, 746, 751, 0, 0, 764, 0, 1169, 0, + 1175, 0, 0, 0, 746, 531, 0, 706, 763, 110, + 0, 744, 745, 634, 634, 588, 0, 569, 756, 0, + 0, 759, 757, 0, 759, 0, 0, 0, 759, 755, + 714, 0, 634, 0, 744, 747, 634, 0, 766, 1335, + 0, 0, 0, 0, 0, 1459, 1457, 1458, 1463, 0, + 0, 0, 1246, 1248, 1249, 1118, 1259, 1009, 0, 1821, + 1822, 1823, 1190, 1824, 1825, 1827, 1828, 1829, 968, 1574, + 1830, 1257, 1832, 1834, 1835, 1837, 1838, 1839, 1840, 1841, + 1842, 0, 1258, 1845, 1678, 1850, 1851, 1853, 1856, 1857, + 1256, 1862, 0, 0, 0, 1225, 1141, 0, 1008, 0, + 0, 0, 1191, 1199, 1001, 0, 0, 810, 811, 832, + 833, 812, 838, 839, 841, 813, 0, 1221, 902, 997, + 1209, 1006, 1010, 1048, 1012, 1028, 1015, 1085, 1007, 0, + 1013, 999, 1217, 569, 1215, 0, 1000, 1245, 569, 1213, + 1394, 1392, 1398, 1393, 0, 0, 0, 0, 0, 110, + 1438, 1437, 1429, 1427, 1428, 1426, 1425, 1432, 0, 1434, + 1341, 1136, 1138, 0, 561, 0, 0, 0, 513, 512, + 514, 3, 0, 0, 0, 0, 581, 582, 0, 0, 0, 0, 0, 0, 0, 0, 677, 608, 609, 611, 674, 678, 686, 0, 0, 0, 0, 0, 520, 0, - 1474, 1468, 1466, 0, 0, 0, 139, 139, 0, 0, - 0, 0, 0, 99, 48, 92, 0, 0, 0, 0, - 234, 247, 0, 0, 0, 0, 0, 244, 0, 0, - 227, 221, 223, 50, 0, 139, 0, 46, 0, 0, - 0, 52, 1450, 0, 483, 1194, 0, 119, 120, 118, - 111, 0, 2009, 1871, 1872, 1873, 1874, 1824, 1875, 1876, - 0, 1877, 1878, 1830, 1880, 1881, 1882, 1883, 1884, 1885, - 1886, 1887, 1837, 1889, 1890, 1891, 1892, 1893, 1894, 2035, - 1895, 1851, 1897, 1857, 0, 1898, 1018, 112, 1259, 1141, - 593, 1139, 1272, 0, 0, 1324, 0, 0, 0, 0, - 481, 0, 0, 0, 0, 1284, 0, 0, 1606, 201, - 1606, 366, 0, 1606, 366, 1606, 0, 1606, 206, 210, - 1298, 1301, 0, 431, 426, 424, 423, 425, 1606, 253, - 0, 0, 1267, 436, 437, 0, 405, 0, 0, 407, - 0, 0, 217, 0, 215, 0, 401, 155, 0, 228, - 1382, 1383, 1381, 0, 0, 1340, 231, 1376, 1385, 1375, - 1384, 1339, 248, 1334, 0, 0, 1330, 471, 0, 0, - 0, 0, 1148, 877, 876, 860, 861, 874, 875, 862, - 863, 870, 871, 879, 878, 868, 869, 864, 865, 858, - 859, 866, 867, 872, 873, 856, 857, 1161, 1149, 1150, - 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, - 0, 0, 705, 703, 0, 0, 0, 0, 0, 0, - 1188, 0, 970, 996, 0, 0, 0, 1133, 1171, 0, - 0, 0, 0, 0, 0, 1133, 1177, 0, 0, 728, - 740, 0, 627, 633, 704, 702, 0, 1211, 697, 0, - 774, 754, 0, 753, 0, 0, 756, 750, 0, 751, - 0, 0, 0, 0, 752, 0, 0, 0, 0, 700, - 0, 740, 0, 701, 771, 1416, 1415, 1411, 1398, 1406, - 195, 0, 1263, 1899, 1900, 1901, 818, 1902, 847, 825, - 847, 847, 1903, 1904, 1905, 1906, 814, 814, 827, 1907, - 1908, 1909, 1910, 1911, 815, 816, 852, 1912, 1913, 1914, - 1915, 1916, 0, 0, 1917, 847, 1918, 814, 1919, 1920, - 1921, 819, 1922, 782, 1923, 0, 1924, 817, 783, 1925, - 855, 855, 1926, 0, 842, 1927, 1264, 1265, 0, 1144, - 792, 800, 801, 802, 803, 828, 829, 804, 834, 835, - 805, 899, 0, 814, 155, 1461, 1477, 0, 1138, 1004, - 846, 833, 1186, 0, 841, 840, 0, 1138, 823, 822, - 821, 1009, 0, 820, 1095, 847, 847, 845, 925, 824, - 0, 0, 0, 0, 0, 851, 0, 849, 926, 904, - 905, 0, 1221, 1230, 1133, 1137, 0, 1007, 1133, 0, - 1000, 1001, 0, 1085, 1087, 0, 0, 1189, 1244, 1008, - 0, 1249, 0, 0, 899, 899, 1217, 1115, 0, 1105, - 1108, 0, 0, 1112, 1113, 1114, 0, 0, 0, 1209, - 0, 1123, 1125, 0, 0, 941, 1121, 0, 944, 0, - 0, 0, 0, 1109, 1110, 1111, 1101, 1102, 1103, 1104, - 1106, 1107, 1119, 1100, 922, 0, 997, 0, 1048, 0, - 921, 1215, 695, 0, 1247, 695, 1400, 1404, 1405, 1403, - 1399, 0, 1394, 1393, 1396, 1397, 1479, 0, 1436, 1420, - 0, 1417, 1136, 690, 563, 1235, 0, 567, 1443, 1441, - 160, 159, 0, 0, 536, 535, 602, 594, 596, 602, - 0, 534, 0, 650, 651, 0, 0, 0, 0, 683, - 681, 1243, 1256, 638, 612, 637, 0, 0, 616, 0, - 642, 900, 676, 518, 606, 607, 610, 517, 0, 679, - 0, 689, 0, 555, 557, 540, 554, 552, 537, 545, - 677, 611, 0, 1467, 0, 0, 0, 0, 0, 1606, - 0, 0, 785, 83, 64, 318, 138, 0, 0, 0, - 0, 0, 0, 0, 91, 88, 89, 90, 0, 0, - 0, 0, 1263, 232, 233, 246, 0, 237, 238, 235, - 239, 240, 0, 0, 225, 226, 0, 0, 0, 0, - 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1451, 1444, 1190, 1195, 593, 593, 593, 0, 591, 592, - 0, 0, 0, 0, 0, 470, 364, 374, 0, 0, - 0, 1288, 0, 0, 0, 0, 0, 205, 0, 401, - 1289, 1287, 1291, 1290, 1292, 1577, 189, 0, 0, 200, - 197, 0, 363, 337, 0, 0, 1303, 0, 0, 0, - 0, 0, 0, 1606, 353, 1300, 0, 1448, 0, 0, - 251, 438, 1268, 0, 435, 438, 1234, 0, 438, 219, - 0, 0, 1336, 1378, 229, 249, 230, 250, 483, 478, - 508, 0, 486, 491, 468, 0, 468, 0, 488, 492, - 468, 487, 0, 468, 482, 1412, 0, 1041, 0, 1031, - 0, 0, 763, 0, 0, 1032, 972, 973, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 990, 989, 1033, 767, - 0, 770, 0, 0, 1169, 1170, 0, 1034, 0, 0, - 1176, 0, 0, 0, 1039, 0, 707, 0, 0, 0, - 622, 626, 629, 0, 632, 569, 525, 1597, 1637, 0, - 580, 580, 580, 578, 568, 0, 654, 0, 0, 729, - 0, 0, 731, 733, 0, 0, 736, 713, 712, 0, - 0, 0, 0, 775, 0, 1239, 0, 0, 196, 0, - 0, 0, 800, 0, 0, 0, 790, 786, 0, 880, - 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, - 891, 806, 1276, 0, 812, 1281, 1282, 1279, 1275, 1278, - 1280, 1283, 0, 0, 0, 0, 1185, 1181, 0, 0, - 0, 0, 1090, 1092, 1094, 0, 844, 843, 1099, 1105, - 1108, 1112, 1113, 1114, 1109, 1110, 1111, 1101, 1102, 1103, - 1104, 1106, 1107, 0, 1127, 0, 1081, 0, 0, 0, - 0, 0, 0, 1220, 0, 968, 0, 1002, 1013, 0, - 0, 1088, 1017, 1222, 1197, 0, 0, 0, 1252, 1251, - 901, 910, 913, 945, 946, 917, 918, 919, 923, 1274, - 1273, 1216, 0, 1208, 0, 0, 902, 927, 932, 0, - 1178, 962, 0, 950, 0, 940, 0, 948, 952, 928, - 943, 0, 924, 0, 1209, 1124, 1126, 0, 1122, 0, - 914, 915, 916, 906, 907, 908, 909, 911, 912, 920, - 1098, 1096, 1097, 0, 1195, 0, 1207, 0, 0, 1050, - 0, 0, 947, 1213, 0, 774, 593, 774, 0, 899, - 1437, 1271, 1430, 1419, 1271, 1134, 1236, 1270, 565, 0, - 0, 0, 1439, 146, 150, 0, 1196, 180, 182, 695, - 0, 600, 601, 605, 0, 0, 605, 584, 533, 1848, - 1730, 0, 0, 0, 0, 643, 684, 0, 675, 640, - 641, 0, 639, 1243, 644, 1242, 645, 648, 649, 617, - 1231, 685, 687, 0, 680, 0, 1237, 539, 558, 0, - 0, 0, 0, 0, 522, 521, 691, 0, 49, 0, - 1606, 66, 0, 0, 0, 0, 0, 0, 268, 0, - 368, 268, 104, 1606, 438, 1606, 438, 1501, 1572, 1748, - 0, 62, 342, 95, 0, 132, 371, 0, 327, 85, - 100, 125, 0, 0, 222, 51, 236, 241, 128, 245, - 242, 1308, 243, 139, 0, 47, 0, 126, 0, 1306, - 0, 0, 53, 130, 1310, 1452, 0, 1194, 0, 591, - 591, 591, 0, 1140, 0, 0, 0, 1142, 1143, 940, - 1317, 1318, 1319, 1316, 456, 469, 0, 365, 0, 480, - 459, 460, 470, 1286, 0, 201, 366, 0, 366, 0, - 210, 1288, 0, 0, 191, 187, 0, 0, 0, 0, - 364, 356, 354, 387, 0, 361, 355, 0, 0, 313, - 0, 1495, 0, 0, 0, 0, 450, 0, 0, 205, - 211, 0, 0, 0, 253, 254, 404, 1269, 406, 0, - 408, 218, 216, 1331, 475, 0, 474, 479, 473, 477, - 472, 0, 467, 0, 501, 0, 0, 0, 0, 0, - 0, 0, 0, 1028, 1146, 0, 1164, 1163, 971, 978, - 981, 985, 986, 987, 1165, 0, 0, 0, 982, 983, - 984, 974, 975, 976, 977, 979, 980, 988, 772, 0, - 0, 766, 1174, 1173, 1167, 1168, 0, 1036, 1037, 1038, - 1175, 0, 0, 741, 620, 618, 621, 623, 619, 0, - 0, 774, 580, 580, 580, 580, 577, 0, 0, 0, - 773, 0, 671, 735, 0, 759, 0, 732, 0, 0, - 723, 0, 730, 779, 746, 0, 0, 748, 1407, 796, - 0, 791, 787, 0, 0, 0, 797, 0, 0, 0, - 0, 0, 0, 0, 1145, 586, 1005, 0, 0, 0, - 1182, 0, 967, 813, 826, 0, 1093, 1015, 0, 1116, - 1080, 854, 853, 855, 855, 0, 0, 0, 1229, 0, - 1134, 1084, 1086, 1230, 1010, 838, 899, 0, 0, 0, - 0, 0, 0, 0, 951, 942, 0, 949, 953, 0, - 0, 0, 936, 0, 0, 934, 963, 930, 0, 0, - 964, 1194, 0, 1198, 0, 0, 1049, 1058, 698, 694, - 654, 591, 654, 0, 1401, 1421, 1418, 566, 155, 1440, - 0, 169, 0, 0, 0, 0, 172, 186, 183, 1439, - 0, 0, 595, 597, 0, 1117, 605, 599, 647, 646, - 0, 615, 682, 613, 0, 688, 0, 556, 0, 542, - 0, 716, 0, 0, 0, 0, 0, 317, 0, 0, - 0, 268, 0, 376, 0, 383, 0, 0, 368, 349, - 84, 0, 0, 0, 58, 103, 76, 68, 54, 82, - 0, 0, 87, 0, 80, 97, 98, 96, 101, 0, - 278, 303, 0, 0, 314, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 483, 1195, 1191, 1195, - 0, 0, 0, 593, 589, 590, 1019, 0, 455, 507, - 504, 505, 503, 227, 375, 0, 0, 199, 363, 0, - 1303, 0, 0, 1285, 401, 0, 192, 0, 190, 0, - 201, 366, 0, 341, 337, 362, 335, 334, 336, 0, - 1496, 220, 0, 1490, 366, 1302, 0, 0, 451, 0, - 445, 210, 0, 0, 1297, 252, 438, 0, 463, 502, - 509, 489, 494, 0, 500, 496, 495, 490, 498, 497, - 493, 1029, 1040, 1162, 0, 0, 0, 0, 765, 768, - 0, 1035, 1030, 739, 0, 0, 654, 0, 0, 0, - 0, 571, 570, 576, 0, 0, 1052, 734, 0, 0, - 0, 721, 711, 717, 0, 0, 0, 0, 777, 776, - 747, 800, 0, 780, 800, 0, 800, 0, 798, 0, - 807, 892, 893, 894, 895, 896, 897, 898, 832, 0, - 1184, 1180, 1089, 1091, 1128, 850, 848, 1219, 1133, 1224, - 1226, 0, 0, 0, 1083, 969, 1250, 903, 0, 0, - 933, 1179, 954, 0, 0, 0, 929, 1116, 0, 0, - 0, 0, 0, 938, 0, 1202, 1195, 0, 1201, 0, - 0, 0, 0, 1024, 699, 671, 0, 671, 0, 0, - 1438, 0, 1433, 147, 148, 149, 0, 0, 0, 164, - 141, 0, 0, 181, 169, 157, 603, 604, 0, 598, - 614, 1232, 1238, 541, 0, 1007, 0, 0, 538, 0, - 133, 268, 0, 0, 65, 0, 385, 329, 377, 360, - 344, 0, 0, 0, 269, 0, 402, 0, 0, 350, - 0, 0, 0, 0, 330, 0, 0, 289, 0, 0, - 360, 0, 367, 285, 286, 0, 57, 77, 0, 73, - 0, 102, 0, 0, 0, 0, 0, 60, 72, 0, - 55, 0, 438, 438, 63, 1263, 1899, 1900, 1901, 1902, - 1903, 1904, 1905, 1906, 1907, 1908, 2019, 1909, 1910, 1911, - 1912, 1913, 1914, 1915, 1916, 2028, 1917, 275, 1918, 1675, - 1919, 1920, 1921, 1922, 1923, 0, 1924, 783, 1925, 1926, - 2107, 1927, 1101, 1102, 273, 274, 370, 270, 1264, 271, - 378, 272, 0, 373, 328, 129, 1309, 0, 127, 0, - 1307, 136, 134, 131, 1311, 1445, 0, 0, 1022, 1023, - 1020, 591, 0, 0, 0, 483, 462, 0, 0, 1495, - 0, 0, 0, 0, 1606, 0, 188, 0, 1303, 198, - 363, 0, 393, 313, 388, 0, 1495, 1493, 0, 1303, - 1489, 0, 442, 0, 202, 0, 0, 0, 409, 476, - 0, 499, 991, 0, 0, 0, 0, 630, 0, 636, - 671, 575, 574, 573, 572, 653, 1546, 1831, 1729, 0, - 657, 652, 655, 660, 662, 661, 663, 659, 670, 0, - 673, 758, 1129, 1131, 0, 0, 0, 0, 722, 0, - 724, 0, 726, 0, 778, 794, 0, 795, 0, 793, - 788, 799, 1183, 1227, 1228, 1223, 0, 900, 960, 958, - 955, 0, 956, 937, 0, 0, 935, 931, 0, 965, - 0, 0, 1199, 0, 1044, 0, 1047, 1061, 1057, 1056, - 1052, 1019, 1052, 1402, 564, 168, 145, 171, 170, 0, - 1196, 178, 0, 0, 169, 0, 173, 452, 0, 0, - 553, 715, 546, 547, 0, 381, 67, 0, 360, 0, - 268, 346, 345, 348, 343, 347, 0, 403, 0, 0, - 287, 0, 294, 332, 333, 331, 288, 360, 366, 290, - 0, 0, 0, 69, 59, 56, 61, 70, 0, 0, - 71, 74, 779, 86, 79, 1263, 2028, 2037, 0, 0, - 0, 0, 0, 1193, 1192, 0, 458, 457, 506, 454, - 465, 227, 0, 0, 337, 1492, 0, 0, 447, 0, - 0, 0, 363, 193, 0, 0, 0, 1495, 0, 0, - 265, 0, 310, 0, 213, 1494, 0, 0, 1481, 0, - 0, 0, 1295, 1296, 0, 464, 992, 0, 993, 769, - 0, 0, 628, 1052, 0, 0, 0, 664, 658, 0, - 1051, 1053, 0, 625, 1132, 718, 0, 720, 0, 744, - 593, 0, 744, 727, 789, 781, 1225, 1042, 0, 957, - 961, 959, 939, 1195, 1203, 1195, 1200, 1046, 1060, 1063, - 673, 1248, 673, 0, 0, 156, 0, 0, 153, 140, - 158, 1118, 543, 544, 0, 268, 0, 359, 382, 299, - 277, 0, 0, 0, 284, 291, 392, 293, 0, 78, - 94, 0, 0, 372, 137, 135, 1021, 483, 0, 1303, - 313, 1489, 444, 204, 0, 0, 0, 337, 220, 1491, - 326, 319, 320, 321, 322, 323, 324, 325, 340, 339, - 311, 312, 0, 0, 0, 0, 0, 446, 0, 1297, - 0, 175, 184, 0, 175, 994, 631, 0, 673, 0, - 0, 0, 656, 0, 0, 672, 0, 529, 1130, 0, - 710, 708, 591, 0, 709, 0, 0, 0, 0, 593, - 625, 625, 142, 0, 143, 179, 0, 0, 0, 366, - 384, 358, 0, 351, 297, 296, 298, 302, 0, 300, - 0, 316, 0, 309, 277, 0, 81, 0, 379, 453, - 461, 0, 267, 1483, 363, 0, 1489, 313, 1495, 1489, - 0, 1486, 0, 443, 203, 0, 0, 0, 177, 1303, - 0, 177, 0, 625, 666, 0, 665, 1055, 1054, 627, - 719, 0, 0, 1043, 1205, 1204, 0, 1067, 528, 527, - 0, 0, 0, 0, 392, 0, 338, 0, 0, 299, - 0, 292, 389, 390, 391, 0, 305, 295, 306, 75, - 93, 380, 0, 363, 1484, 266, 214, 1482, 1487, 1488, - 0, 175, 174, 602, 176, 774, 185, 602, 635, 530, - 667, 624, 0, 725, 1062, 0, 0, 0, 0, 0, - 152, 774, 163, 0, 309, 357, 352, 276, 301, 315, - 0, 0, 0, 307, 0, 308, 1489, 0, 177, 605, - 1293, 605, 1817, 1547, 1783, 0, 1079, 1068, 1079, 1079, - 1059, 144, 151, 0, 268, 281, 0, 280, 0, 369, - 304, 1485, 1303, 602, 165, 166, 0, 1072, 1071, 1070, - 1074, 1073, 0, 1066, 1064, 1065, 774, 386, 279, 283, - 282, 774, 605, 0, 0, 1076, 0, 1077, 162, 1294, - 167, 1069, 1075, 1078 + 1274, 1477, 1471, 1469, 0, 0, 0, 139, 139, 0, + 0, 0, 0, 0, 99, 48, 92, 0, 0, 0, + 0, 234, 247, 0, 0, 0, 0, 0, 244, 0, + 0, 227, 50, 221, 223, 0, 139, 0, 46, 0, + 0, 0, 52, 1453, 0, 483, 1197, 0, 119, 120, + 118, 111, 0, 2012, 1874, 1875, 1876, 1877, 1827, 1878, + 1879, 0, 1880, 1881, 1833, 1883, 1884, 1885, 1886, 1887, + 1888, 1889, 1890, 1840, 1892, 1893, 1894, 1895, 1896, 1897, + 2038, 1898, 1854, 1900, 1860, 0, 1901, 1021, 1144, 593, + 1142, 1275, 0, 112, 1262, 0, 1327, 0, 0, 0, + 0, 481, 0, 0, 0, 0, 1287, 0, 1609, 206, + 210, 0, 1609, 201, 1609, 366, 0, 1609, 366, 1609, + 0, 1301, 1304, 0, 431, 426, 424, 423, 425, 1609, + 253, 0, 0, 1270, 436, 437, 0, 405, 0, 0, + 407, 0, 0, 217, 0, 215, 0, 401, 155, 0, + 228, 1385, 1386, 1384, 0, 0, 1379, 1343, 231, 248, + 1388, 1378, 1387, 1342, 1337, 0, 0, 1333, 471, 0, + 0, 0, 0, 1151, 879, 878, 862, 863, 876, 877, + 864, 865, 872, 873, 881, 880, 870, 871, 866, 867, + 860, 861, 868, 869, 874, 875, 858, 859, 1164, 1152, + 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1162, + 1163, 0, 0, 705, 703, 0, 0, 0, 0, 0, + 0, 1191, 0, 972, 1007, 0, 0, 0, 1136, 1174, + 0, 0, 0, 0, 0, 0, 1136, 1180, 0, 0, + 730, 742, 0, 627, 633, 704, 702, 0, 1214, 697, + 0, 776, 0, 756, 0, 755, 0, 0, 758, 752, + 0, 753, 0, 0, 0, 0, 754, 0, 0, 0, + 0, 0, 700, 0, 742, 0, 701, 773, 1419, 1418, + 1414, 1401, 1409, 195, 0, 1266, 1902, 1903, 1904, 820, + 1905, 849, 827, 849, 849, 1906, 1907, 1908, 1909, 816, + 816, 829, 1910, 1911, 1912, 1913, 1914, 817, 818, 854, + 1915, 1916, 1917, 1918, 1919, 0, 0, 1920, 849, 1921, + 816, 1922, 1923, 1924, 821, 1925, 784, 1926, 0, 1927, + 819, 785, 1928, 857, 857, 1929, 0, 844, 1930, 0, + 1147, 794, 802, 803, 804, 805, 830, 831, 806, 836, + 837, 807, 901, 0, 816, 1267, 1268, 155, 1464, 1480, + 0, 1141, 1016, 848, 835, 1189, 0, 843, 842, 0, + 1141, 825, 824, 823, 1003, 0, 822, 1098, 849, 849, + 847, 927, 826, 0, 0, 0, 0, 0, 853, 0, + 851, 928, 906, 907, 0, 1224, 1233, 1136, 1140, 0, + 1001, 1136, 0, 0, 1088, 1090, 0, 1018, 1019, 0, + 1192, 1247, 1002, 0, 1252, 0, 0, 901, 901, 1220, + 1118, 0, 1108, 1111, 0, 0, 1115, 1116, 1117, 0, + 0, 0, 1212, 0, 1126, 1128, 0, 0, 943, 1124, + 0, 946, 0, 0, 0, 0, 1112, 1113, 1114, 1104, + 1105, 1106, 1107, 1109, 1110, 1122, 1103, 924, 0, 998, + 0, 1051, 0, 923, 1218, 695, 0, 1250, 695, 1403, + 1407, 1408, 1402, 1406, 0, 1397, 1396, 1399, 1400, 1482, + 0, 1439, 1423, 0, 1420, 1139, 690, 563, 1238, 0, + 567, 1444, 160, 159, 0, 0, 536, 535, 602, 594, + 596, 602, 0, 534, 0, 650, 651, 0, 0, 0, + 0, 683, 681, 1246, 1259, 638, 612, 637, 0, 0, + 616, 0, 642, 902, 676, 518, 606, 607, 610, 517, + 0, 679, 0, 689, 0, 555, 557, 540, 554, 552, + 537, 545, 677, 611, 0, 1446, 1470, 0, 0, 0, + 0, 0, 1609, 0, 0, 787, 83, 64, 318, 138, + 0, 0, 0, 0, 0, 0, 0, 91, 88, 89, + 90, 0, 0, 0, 0, 1266, 232, 233, 246, 0, + 237, 238, 235, 239, 240, 0, 0, 225, 226, 0, + 0, 0, 0, 224, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1454, 1447, 1193, 1198, 593, 593, 593, + 0, 591, 592, 0, 0, 0, 0, 0, 470, 364, + 374, 0, 0, 0, 1291, 205, 0, 0, 0, 0, + 0, 0, 401, 1294, 1292, 1290, 1293, 1295, 1580, 189, + 0, 0, 0, 0, 0, 197, 200, 0, 363, 337, + 0, 0, 1306, 0, 0, 0, 1609, 353, 1303, 0, + 1451, 0, 0, 251, 438, 1271, 0, 435, 438, 1237, + 0, 438, 219, 0, 0, 1339, 1381, 229, 249, 230, + 250, 483, 478, 508, 0, 486, 491, 468, 0, 468, + 0, 488, 492, 468, 487, 0, 468, 482, 1415, 0, + 1044, 0, 1034, 0, 0, 765, 0, 0, 1035, 974, + 975, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 992, + 991, 1036, 769, 0, 772, 0, 0, 1172, 1173, 0, + 1037, 0, 0, 1179, 0, 0, 0, 1042, 0, 707, + 0, 0, 0, 622, 626, 629, 0, 632, 569, 525, + 1600, 1640, 0, 580, 580, 580, 578, 568, 0, 654, + 0, 0, 0, 731, 0, 0, 733, 735, 0, 0, + 738, 0, 713, 712, 0, 0, 0, 0, 777, 0, + 1242, 0, 0, 196, 0, 0, 0, 802, 0, 0, + 0, 792, 788, 0, 882, 883, 884, 885, 886, 887, + 888, 889, 890, 891, 892, 893, 808, 1279, 0, 814, + 1282, 1283, 1284, 1281, 1278, 1285, 1286, 0, 0, 0, + 0, 1188, 1184, 0, 0, 0, 0, 1093, 1095, 1097, + 0, 846, 845, 1102, 1108, 1111, 1115, 1116, 1117, 1112, + 1113, 1114, 1104, 1105, 1106, 1107, 1109, 1110, 0, 1130, + 0, 1084, 0, 0, 0, 0, 0, 0, 1223, 0, + 970, 0, 1014, 1005, 0, 0, 1091, 1020, 1225, 1200, + 0, 0, 0, 1255, 1254, 903, 912, 915, 947, 948, + 919, 920, 921, 925, 1277, 1276, 1219, 0, 1211, 0, + 0, 904, 929, 934, 0, 1181, 964, 0, 952, 0, + 942, 0, 950, 954, 930, 945, 0, 926, 0, 1212, + 1127, 1129, 0, 1125, 0, 916, 917, 918, 908, 909, + 910, 911, 913, 914, 922, 1101, 1099, 1100, 0, 1198, + 0, 1210, 0, 0, 1053, 0, 0, 949, 1216, 0, + 776, 593, 776, 0, 901, 1440, 1274, 1433, 1274, 1422, + 1137, 1239, 1273, 565, 0, 0, 0, 1442, 146, 150, + 0, 1199, 180, 182, 695, 0, 600, 601, 605, 0, + 0, 605, 584, 533, 1851, 1733, 0, 0, 0, 0, + 643, 684, 0, 675, 640, 641, 0, 639, 1246, 644, + 1245, 645, 648, 649, 617, 1234, 685, 687, 0, 680, + 0, 1240, 539, 558, 0, 0, 0, 0, 0, 522, + 521, 691, 0, 49, 0, 1609, 66, 0, 0, 0, + 0, 0, 0, 268, 0, 368, 268, 104, 1609, 438, + 1609, 438, 1504, 1575, 1751, 0, 62, 342, 95, 0, + 132, 371, 0, 327, 85, 100, 125, 0, 0, 51, + 222, 236, 241, 128, 245, 242, 1311, 243, 139, 0, + 47, 0, 126, 0, 1309, 0, 0, 53, 130, 1313, + 1455, 0, 1197, 0, 591, 591, 591, 0, 1143, 0, + 0, 0, 1145, 1146, 942, 1321, 1320, 1322, 1319, 456, + 469, 0, 365, 0, 480, 459, 460, 470, 1289, 210, + 0, 201, 366, 0, 366, 0, 1291, 0, 0, 191, + 187, 205, 211, 0, 0, 0, 0, 0, 364, 356, + 354, 387, 0, 361, 355, 0, 0, 313, 0, 1498, + 0, 0, 0, 0, 450, 0, 0, 0, 0, 253, + 254, 404, 1272, 406, 0, 408, 218, 216, 1334, 475, + 0, 474, 479, 477, 473, 472, 0, 467, 0, 501, + 0, 0, 0, 0, 0, 0, 0, 0, 1031, 1149, + 0, 1167, 1166, 973, 980, 983, 987, 988, 989, 1168, + 0, 0, 0, 984, 985, 986, 976, 977, 978, 979, + 981, 982, 990, 774, 0, 0, 768, 1177, 1176, 1170, + 1171, 0, 1039, 1040, 1041, 1178, 0, 0, 743, 620, + 618, 621, 623, 619, 0, 0, 776, 580, 580, 580, + 580, 577, 0, 0, 0, 775, 0, 671, 739, 737, + 0, 761, 0, 734, 717, 740, 0, 725, 0, 732, + 781, 748, 0, 0, 750, 1410, 798, 0, 793, 789, + 0, 0, 0, 799, 0, 0, 0, 0, 0, 0, + 0, 1148, 586, 1017, 0, 0, 0, 1185, 0, 969, + 815, 828, 0, 1096, 1011, 0, 1119, 1083, 856, 855, + 857, 857, 0, 0, 0, 1232, 0, 1137, 1087, 1089, + 1233, 1004, 840, 901, 0, 0, 0, 0, 0, 0, + 0, 953, 944, 0, 951, 955, 0, 0, 0, 938, + 0, 0, 936, 965, 932, 0, 0, 966, 1197, 0, + 1201, 0, 0, 1052, 1061, 698, 694, 654, 591, 654, + 0, 1404, 1424, 1421, 566, 155, 1443, 0, 169, 0, + 0, 0, 0, 172, 186, 183, 1442, 0, 0, 595, + 597, 0, 1120, 605, 599, 647, 646, 0, 615, 682, + 613, 0, 688, 0, 556, 0, 542, 0, 716, 0, + 0, 0, 0, 0, 317, 0, 0, 0, 268, 0, + 376, 0, 383, 0, 0, 368, 349, 84, 0, 0, + 0, 58, 103, 76, 68, 54, 82, 0, 0, 87, + 0, 80, 97, 98, 96, 101, 0, 278, 303, 0, + 0, 314, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 483, 1198, 1194, 1198, 0, 0, 0, + 593, 589, 590, 1022, 0, 455, 507, 504, 505, 503, + 227, 375, 0, 0, 0, 199, 363, 0, 1306, 0, + 1288, 401, 0, 192, 0, 190, 210, 0, 0, 201, + 366, 0, 341, 337, 362, 335, 334, 336, 0, 1499, + 220, 0, 1493, 366, 1305, 0, 0, 451, 0, 445, + 0, 1300, 252, 438, 0, 463, 502, 509, 489, 494, + 0, 500, 496, 495, 490, 498, 497, 493, 1032, 1043, + 1165, 0, 0, 0, 0, 767, 770, 0, 1038, 1033, + 741, 0, 0, 654, 0, 0, 0, 0, 571, 570, + 576, 0, 0, 1055, 736, 0, 0, 0, 723, 711, + 718, 719, 0, 0, 0, 779, 778, 749, 802, 0, + 782, 802, 0, 802, 0, 800, 0, 809, 894, 895, + 896, 897, 898, 899, 900, 834, 0, 1187, 1183, 1092, + 1094, 1131, 852, 850, 1222, 1136, 1227, 1229, 0, 0, + 0, 1086, 971, 1253, 905, 0, 0, 935, 1182, 956, + 0, 0, 0, 931, 1119, 0, 0, 0, 0, 0, + 940, 0, 1205, 1198, 0, 1204, 0, 0, 0, 0, + 1027, 699, 671, 0, 671, 0, 0, 1441, 0, 1436, + 147, 148, 149, 0, 0, 0, 164, 141, 0, 0, + 181, 169, 157, 603, 604, 0, 598, 614, 1235, 1241, + 541, 0, 1001, 0, 0, 538, 0, 133, 268, 0, + 0, 65, 0, 385, 329, 377, 360, 344, 0, 0, + 0, 269, 0, 402, 0, 0, 350, 0, 0, 0, + 0, 330, 0, 0, 289, 0, 0, 360, 0, 367, + 285, 286, 0, 57, 77, 0, 73, 0, 102, 0, + 0, 0, 0, 0, 60, 72, 0, 55, 0, 438, + 438, 63, 1266, 1902, 1903, 1904, 1905, 1906, 1907, 1908, + 1909, 1910, 1911, 2022, 1912, 1913, 1914, 1915, 1916, 1917, + 1918, 1919, 2031, 1920, 275, 1921, 1678, 1922, 1923, 1924, + 1925, 1926, 0, 1927, 785, 1928, 1929, 2110, 1930, 1104, + 1105, 274, 273, 370, 270, 378, 272, 0, 1267, 271, + 373, 328, 129, 1312, 0, 127, 0, 1310, 136, 134, + 131, 1314, 1448, 0, 0, 1025, 1026, 1023, 591, 0, + 0, 0, 483, 462, 0, 0, 0, 1498, 0, 0, + 0, 1609, 0, 188, 0, 0, 202, 1306, 198, 363, + 0, 393, 313, 388, 0, 1498, 1496, 0, 1306, 1492, + 0, 442, 0, 0, 0, 409, 476, 0, 499, 993, + 0, 0, 0, 0, 630, 0, 636, 671, 575, 574, + 573, 572, 653, 1549, 1834, 1732, 0, 657, 652, 655, + 660, 662, 661, 663, 659, 670, 0, 673, 760, 1132, + 1134, 0, 0, 0, 0, 724, 726, 0, 728, 0, + 780, 796, 0, 797, 0, 795, 790, 801, 1186, 1230, + 1231, 1226, 0, 902, 962, 960, 957, 0, 958, 939, + 0, 0, 937, 933, 0, 967, 0, 0, 1202, 0, + 1047, 0, 1050, 1064, 1060, 1059, 1055, 1022, 1055, 1405, + 564, 168, 145, 171, 170, 0, 1199, 178, 0, 0, + 169, 0, 173, 452, 0, 0, 553, 715, 546, 547, + 0, 381, 67, 0, 360, 0, 268, 346, 345, 348, + 343, 347, 0, 403, 0, 0, 287, 0, 294, 332, + 333, 331, 288, 360, 366, 290, 0, 0, 0, 69, + 59, 56, 61, 70, 0, 0, 71, 74, 781, 86, + 79, 1266, 2031, 2040, 0, 0, 0, 0, 0, 1196, + 1195, 0, 458, 457, 506, 454, 465, 227, 0, 0, + 0, 337, 1495, 0, 0, 447, 0, 0, 363, 193, + 0, 0, 0, 0, 1498, 0, 0, 265, 0, 310, + 0, 213, 1497, 0, 0, 1484, 0, 0, 1298, 1299, + 0, 464, 994, 0, 995, 771, 0, 0, 628, 1055, + 0, 0, 0, 664, 658, 0, 1054, 1056, 0, 625, + 1135, 720, 0, 722, 0, 746, 0, 746, 729, 791, + 783, 1228, 1045, 0, 959, 963, 961, 941, 1198, 1206, + 1198, 1203, 1049, 1063, 1066, 673, 1251, 673, 0, 0, + 156, 0, 0, 153, 140, 158, 1121, 543, 544, 0, + 268, 0, 359, 382, 299, 277, 0, 0, 0, 284, + 291, 392, 293, 0, 78, 94, 0, 0, 372, 137, + 135, 1024, 483, 0, 204, 1306, 313, 1492, 444, 0, + 0, 0, 0, 337, 220, 1494, 326, 319, 320, 321, + 322, 323, 324, 325, 340, 339, 311, 312, 0, 0, + 0, 0, 0, 446, 1300, 0, 175, 184, 0, 175, + 996, 631, 0, 673, 0, 0, 0, 656, 0, 0, + 672, 0, 529, 1133, 0, 710, 708, 0, 709, 0, + 0, 0, 0, 593, 625, 625, 142, 0, 143, 179, + 0, 0, 0, 366, 384, 358, 0, 351, 297, 296, + 298, 302, 0, 300, 0, 316, 0, 309, 277, 0, + 81, 0, 379, 453, 461, 0, 267, 1486, 363, 0, + 203, 1492, 313, 1498, 1492, 0, 1489, 0, 443, 0, + 0, 0, 177, 1306, 0, 177, 0, 625, 666, 0, + 665, 1058, 1057, 627, 721, 0, 1046, 1208, 1207, 0, + 1070, 528, 527, 0, 0, 0, 0, 392, 0, 338, + 0, 0, 299, 0, 292, 389, 390, 391, 0, 305, + 295, 306, 75, 93, 380, 0, 363, 1487, 266, 214, + 1485, 1490, 1491, 0, 175, 174, 602, 176, 776, 185, + 602, 635, 530, 667, 624, 727, 1065, 0, 0, 0, + 0, 0, 152, 776, 163, 0, 309, 357, 352, 276, + 301, 315, 0, 0, 0, 307, 0, 308, 1492, 0, + 177, 605, 1296, 605, 1820, 1550, 1786, 0, 1082, 1071, + 1082, 1082, 1062, 144, 151, 0, 268, 281, 0, 280, + 0, 369, 304, 1488, 1306, 602, 165, 166, 0, 1075, + 1074, 1073, 1077, 1076, 0, 1069, 1067, 1068, 776, 386, + 279, 283, 282, 776, 605, 0, 0, 1079, 0, 1080, + 162, 1297, 167, 1072, 1078, 1081 }; -/* YYPGOTO[NTERM-NUM]. */ -static const yytype_int16 yypgoto[] = +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int16 yydefgoto[] = { - -3054, -3054, -3054, 1895, 76, 91, -888, -1189, -927, -1197, - -3054, -111, 94, -3054, -3054, 179, -3054, 1019, -3054, 182, - -794, 546, -3054, 1111, -3054, -3054, 1558, 519, 95, 100, - 2012, -3054, 982, -3054, 1463, 2517, 3539, 1174, -513, -878, - -1251, 18, 17, -3054, -3054, -3054, -3054, -3054, -811, 494, - -1194, -3054, 441, -3054, -3054, -3054, -3054, -193, 168, -2233, - 1, -2149, -2891, -556, -3054, -662, -3054, -311, -3054, -607, - -3054, -864, -613, -648, -2808, -1129, -3054, 1613, -360, -3054, - 595, -3054, -2526, -3054, -3054, 584, -3054, -1158, -3054, -2184, - 158, -589, -2493, -2529, -2153, -906, 236, -595, 219, -2093, - -1186, -3054, 611, -3054, -579, -3054, -881, -1998, 102, -2749, - -1650, -7, -3054, -3054, -3054, -703, -3054, -2495, 108, 1534, - -2100, 110, -1615, -3054, -3054, -1672, 41, -2080, 2, -2087, - 120, -3054, -3054, 123, 33, -578, 288, -3054, 125, -3054, - -3054, 1513, -902, -3054, -3054, 500, 129, 976, -3054, -2545, - -3054, -597, -3054, -626, -615, -3054, -3054, 42, -895, 1499, - -3054, -3054, -3054, 8, -3054, -460, -3054, -3054, -2559, -3054, - 38, -3054, -3054, -3054, -3054, -3054, -395, 305, -3054, -3054, - -536, -2556, -488, -3054, -2974, -2614, -3054, -3054, -636, -2922, - -2067, 130, 78, 1514, 132, 133, -3054, 320, 136, -1136, - 36, 2773, -19, -36, -3054, -32, -3054, -3054, -3054, 651, - -3054, -3054, 22, 53, 1714, -3054, -1010, -3054, -1591, 533, - -3054, 1862, 1865, -2204, -868, -77, -3054, 691, -1654, -2088, - -623, 1140, 1695, 1709, 467, -2190, -3054, -511, -3054, 253, - -3054, -3054, 698, 1185, -1547, -1542, -3054, -2084, -3054, -429, - -316, -3054, -3054, -3054, -3054, -3054, -2483, -2348, -604, 1153, - -3054, 1712, -3054, -3054, -3054, -3054, 7, -1509, 2862, 736, - -84, -3054, -3054, -3054, -3054, 171, -3054, 925, -138, -3054, - 2103, -663, -790, 1915, 140, 251, -1667, 30, 2108, 512, - -3054, -3054, 516, -2045, -1405, 470, -226, 923, -3054, -3054, - -1223, -3054, -1876, -1161, -3054, -3054, -677, 1233, -3054, -3054, - -3054, 1739, 2075, -3054, -3054, 2125, 2141, -3054, -872, 2276, - -752, -1015, 1928, -925, 1932, -929, -931, -954, 1933, 1940, - 1942, 1943, 1944, 1945, -1525, 4806, 325, 4112, -2202, -3054, - 1043, 25, -3054, -1387, 37, -3054, -3054, -3054, -3054, -2280, - -3054, -399, -3054, -397, -3054, -3054, -3054, -1655, -3053, -1678, - -3054, 4206, 858, -3054, -3054, 462, -3054, -3054, -3054, -3054, - -1545, -3054, 5585, 765, -3054, -1982, -3054, -3054, -969, -840, - -1109, -991, -1181, -1913, -3054, -3054, -3054, -3054, -3054, -3054, - -1481, -1750, -211, 824, -3054, -3054, 913, -3054, -3054, -3054, - -1708, -2105, -3054, -3054, -3054, 840, 1515, 148, -823, -1597, - -3054, 882, -2345, -3054, -3054, 463, -3054, -593, -1106, -2410, - 327, -3, -3054, -861, -2489, -3054, -3054, -728, -2617, -1086, - -896, -3054, 137, 1229, 39, -3054, 141, 1278, -3054, -3054, - -3054, 143, -3054, 403, 144, 444, -3054, 973, -3054, 667, - 23, -3054, -3054, -3054, 49, 2849, 11, -2351 + -1, 48, 49, 50, 750, 2593, 2594, 2595, 2235, 1204, + 3360, 2236, 1205, 1206, 2597, 751, 801, 1092, 803, 1093, + 1602, 905, 1238, 1239, 752, 1751, 753, 2816, 2159, 2541, + 3342, 55, 3087, 2162, 1164, 3090, 3307, 2809, 3085, 2542, + 3382, 3436, 3088, 2163, 2164, 3308, 2165, 754, 2654, 2655, + 755, 756, 1835, 59, 1300, 546, 1832, 757, 1333, 1334, + 960, 758, 1836, 1779, 2932, 1224, 1769, 1348, 62, 1853, + 759, 106, 64, 760, 2582, 2933, 3353, 2608, 3491, 2869, + 2870, 3350, 3351, 2585, 2238, 3419, 3420, 2669, 1760, 3414, + 2319, 3294, 2242, 2223, 2871, 2327, 3252, 2981, 2239, 2851, + 2320, 3346, 1848, 2321, 3347, 3106, 2322, 1810, 1839, 2586, + 3421, 2243, 1811, 2581, 2934, 1748, 2323, 3357, 2324, 547, + 2855, 761, 741, 742, 952, 1327, 743, 762, 936, 1845, + 763, 764, 2635, 2297, 3157, 2684, 3158, 2358, 2291, 1357, + 2352, 1873, 1813, 1358, 535, 1887, 2685, 2640, 1874, 765, + 1094, 72, 73, 1007, 74, 3100, 75, 76, 1725, 1726, + 1727, 848, 860, 861, 2155, 1441, 1957, 853, 1168, 1694, + 835, 836, 2281, 876, 1802, 1689, 1690, 2168, 2549, 1718, + 1719, 1177, 1178, 1945, 3322, 1946, 1947, 1434, 1435, 3198, + 1706, 1710, 1711, 2189, 2179, 1697, 2427, 3017, 3018, 3019, + 3020, 3021, 3022, 3023, 1095, 2723, 3209, 1714, 1715, 1180, + 1181, 1182, 1723, 2199, 78, 79, 2140, 2525, 2526, 807, + 3034, 1460, 1728, 2727, 2728, 2729, 3037, 3038, 3039, 808, + 1002, 1003, 1026, 1021, 1449, 1966, 809, 810, 1922, 1923, + 2396, 1028, 1959, 1977, 1978, 2735, 2451, 1529, 2224, 1530, + 1531, 1992, 1532, 1096, 1533, 1561, 1097, 1566, 1535, 1098, + 1099, 1100, 1538, 1101, 1102, 1103, 1104, 1554, 1105, 1106, + 1578, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, + 2003, 2004, 2005, 2006, 1151, 1729, 1108, 1109, 1110, 1111, + 1112, 1113, 1114, 812, 1115, 1116, 1651, 2134, 2524, 3027, + 3206, 3207, 2800, 3075, 3234, 3333, 3450, 3478, 3479, 3505, + 1117, 1118, 1594, 1595, 1596, 2027, 2028, 2029, 2030, 2128, + 1645, 1646, 1119, 2936, 1648, 2050, 3030, 3031, 1152, 1427, + 1589, 1279, 1280, 1543, 1401, 1402, 1408, 1897, 1416, 1420, + 1927, 1928, 1428, 2096, 1120, 2021, 2022, 2468, 1556, 1121, + 1237, 1601, 2795, 2131, 1649, 2090, 1128, 1122, 1129, 1124, + 1585, 1586, 2485, 2767, 2768, 2060, 2196, 1678, 2201, 2202, + 956, 1125, 1126, 1127, 1281, 519, 1544, 3437, 1323, 1157, + 1282, 2086, 766, 1034, 2014, 767, 1296, 1825, 768, 3189, + 2994, 1312, 1849, 2332, 548, 769, 770, 528, 85, 2286, + 917, 86, 87, 88, 885, 1350, 771, 1351, 1352, 967, + 89, 2686, 969, 970, 773, 842, 843, 1472, 1665, 1473, + 774, 818, 1470, 775, 1147, 857, 1148, 1150, 776, 1141, + 2538, 2157, 94, 95, 96, 114, 1235, 777, 829, 830, + 866, 99, 100, 1192, 831, 849, 779, 780, 3185, 781, + 2672, 1306, 529, 521, 522, 1546, 715, 1284, 716 }; -/* YYDEFGOTO[NTERM-NUM]. */ -static const yytype_int16 yydefgoto[] = +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -2987 +static const int yypact[] = +{ + 6315, -13, 722, -2987, -2987, 285, -13, 49878, 64713, 72, + -13, 172, 4065, 51858, -2987, -2987, 46413, 41312, -13, 54828, + 72049, 349, 300, 31840, 382, 55323, 55323, -2987, -2987, -2987, + 64713, 54828, 55818, -13, 340, 65208, -2987, -13, 34315, 52353, + -27, -2987, 54828, 34, 16, 56313, 54828, 2732, 576, 224, + -2987, -2987, -2987, -2987, -2987, 126, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, 144, -2987, 116, 147, 31840, 31840, 1267, 318, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, 311, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + 33820, -2987, -2987, -2987, -2987, -2987, -2987, 56808, 54828, 57303, + 52848, 57798, -2987, 613, 819, -2987, 160, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, 181, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, 396, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, 188, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, 381, -2987, 402, -2987, + 189, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + 1569, -2987, -2987, 818, 2426, 54828, 20, 695, 580, -2987, + 58293, -2987, 591, 54828, -2987, -2987, 638, 856, 855, -2987, + -2987, 53343, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, 46908, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, 815, -2987, -2987, + 594, -2987, 154, -2987, -2987, 605, 625, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, 820, -2987, -2987, -2987, + 835, 65703, 58788, 59283, -2987, 704, 3136, 7105, 72067, 30848, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, 311, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, 55323, 64713, 55323, 717, 729, 1083, 739, 32335, + 756, 34811, 772, 781, 1128, 795, 800, 824, 830, 16, + 31344, 822, 381, -2987, 59778, 59778, -10, 1763, -2987, 59778, + 60273, -2987, 852, -2987, 819, -2987, -2987, -2987, 1185, -2987, + 419, 853, -2987, 60768, 60768, 60768, 877, 1157, -2987, -2987, + -2987, 875, -2987, -2987, 1116, 20517, 20517, 66198, 66198, 819, + 66198, 925, -2987, -2987, 37, -2987, -2987, -2987, 1267, 911, + 381, -2987, -2987, 52353, -2987, -2987, 225, 1287, 20517, 54828, + 943, -2987, 957, 943, 967, 969, 978, -2987, 6315, 1298, + 1209, 52353, 343, 343, 1463, 343, 1056, 1084, 6398, 6686, + -2987, 1859, -2987, 1019, -2987, 54828, 1124, 1049, 1325, -2987, + 911, 1409, 185, 1213, 1419, 4415, 1428, 559, 1443, 985, + 1450, 1576, 20517, 47403, 381, -2987, 11660, 20517, -2987, -2987, + -2987, 1207, -2987, -2987, -2987, -2987, -2987, 54828, 64713, 1112, + 1125, -2987, -2987, -2987, -2987, 1358, 1367, -2987, 1603, 66693, + -2987, -2987, 1179, 61263, 61758, 62253, 62748, 1561, -2987, -2987, + 1504, -2987, -2987, -2987, 1186, -2987, -2987, -2987, 332, 67188, + 1518, 1164, 175, -2987, 1530, 212, -2987, 1533, 1407, 15307, + -2987, 1346, -2987, -2987, -2987, 16, -2987, 284, -2987, -2987, + 43357, -2987, -2987, 72067, 1272, 1195, -2987, 1558, 20517, 20517, + 1223, 7242, 59778, 60273, 20517, 54828, -2987, 20517, 25206, 1227, + 20517, 20517, 12702, 20517, 29858, 59778, 1763, 1231, -2987, 588, + 54828, 1242, -2987, 1334, 1334, 340, 31840, 1540, -2987, 219, + 1568, 1467, -2987, 31840, 1467, 916, 1280, 1580, 1467, -2987, + 598, 1583, 1334, 35306, 1301, -2987, 1334, 1505, -2987, -2987, + 55323, 20517, 15307, 69663, 1779, -2987, -2987, -2987, -2987, 1596, + 64713, 1308, -2987, -2987, -2987, -2987, -2987, -2987, 669, 1827, + 141, 1830, 20517, 141, 141, 1329, 190, 190, -2987, 1524, + 1336, -2987, 195, 1337, 1338, 1849, 1850, 167, 163, 353, + 141, 20517, -2987, 190, 1345, 1855, 1347, 1857, 156, 187, + -2987, 199, 20517, 20517, 20517, 1715, 20517, 10618, -2987, 54828, + 1858, 47403, 692, -2987, 381, 1352, 819, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, 1354, -2987, 180, 6820, -2987, -2987, + -2987, -2987, -2987, 1392, -2987, -2987, -2987, -2987, 1572, 20517, + -2987, -2987, 1356, 1540, -2987, 204, -2987, -2987, 1540, -2987, + -2987, -2987, -2987, -2987, 220, 1766, 20517, 20517, 64713, 381, + 67683, -2987, -2987, -2987, -2987, -2987, -2987, -2987, 441, -2987, + 311, 45045, 1357, 1361, 943, 54828, 54828, 1837, -2987, -2987, + -2987, -2987, 52353, 142, 1660, 1492, -2987, -2987, 1267, 1267, + 15828, 737, 487, 1054, 16349, 21038, 1714, 1597, 227, 218, + 1719, -2987, 1600, 1829, 25206, 20517, 20517, 1056, 1084, 20517, + 957, -2987, -2987, -2987, 1655, 54828, 50373, 937, 941, 1377, + 1464, 1379, 81, 1808, -2987, 1384, -2987, 1485, 54828, 71598, + 192, -2987, 1856, 192, 192, 251, 1864, 1488, 272, 1652, + 362, 257, 1384, 202, -2987, 52353, 197, 761, 1384, 54828, + 1498, 788, 1384, 1820, 64713, 1195, 40944, 1406, -2987, -2987, + -2987, 164, 15307, -2987, 1156, 1311, 1320, 391, 153, 1373, + 1420, 15307, 1478, 1542, 168, 1577, 1587, 1601, 1659, 1665, + 1674, 1679, 1691, 149, 1710, 1712, 1718, 1720, 1726, 1730, + -2987, 1741, 170, 1760, 206, 15307, 1773, -2987, 45045, -1, + -2987, -2987, 1777, 174, -2987, 45134, -2987, 1713, 1508, 1509, + 64713, 1465, 54828, 1570, 865, 1793, 1846, 70143, 1675, -2987, + 1750, 54828, 1678, 202, 1680, 1439, 1916, 1684, 1125, 1685, + 1448, -2987, 68178, 47403, -2987, -2987, -2987, -2987, -2987, 1811, + 1794, 64713, 47403, 1452, -2987, -2987, 64713, -2987, 54828, 54828, + -2987, 54828, 64713, -2987, 526, 45045, 1957, 617, 72067, 48888, + -2987, -2987, -2987, -2987, 1143, 1201, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, 819, 47403, -2987, 3327, 55323, + 43975, 1459, 20517, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, 1461, 1807, -2987, -2987, 6597, 1466, 44015, 1468, 25206, + 25206, 381, 4715, -2987, -2987, 25206, 1469, 49383, 43888, 1462, + 1471, 44363, 16870, 20517, 16870, 16870, 44450, -2987, 1473, 44527, + 59778, 1475, 54828, 53838, -2987, -2987, -2987, 20517, 20517, 1763, + 54333, 1520, 31840, -2987, 31840, -2987, 1758, 31840, -2987, -2987, + 3920, -2987, 31840, 1770, 20517, 31840, -2987, 31840, 1717, 1721, + 1481, 31840, -2987, 54828, 1493, 54828, -2987, -2987, -2987, -2987, + -2987, 45045, -2987, 1491, 633, 1499, -2987, -2987, -2987, -2987, + -2987, 1551, -2987, 1551, 1551, -2987, -2987, -2987, -2987, 1502, + 1502, 1507, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, 1513, 353, -2987, 1551, -2987, + 1502, -2987, -2987, -2987, -2987, -2987, -2987, -2987, 71598, -2987, + -2987, -2987, -2987, 621, 645, -2987, 1514, -2987, -2987, 1515, + -2987, 1503, 1979, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, 8492, 742, 1502, -2987, -2987, 4693, -2987, -2987, + 20517, 20517, -2987, -2987, 1516, 45045, 1550, -2987, -2987, 20517, + 20517, -2987, -2987, -2987, -2987, 2024, -2987, 20517, 1551, 1551, + -2987, 5276, -2987, 39763, 17391, 1610, 1611, 2024, -2987, 2024, + -2987, 5276, 2033, 2033, 37781, -2987, 1695, 44614, -2987, 1536, + 1877, 7400, 1538, 1527, -2987, 1544, 1543, -2987, -2987, 41872, + 137, 381, 381, 20517, -2987, 2024, 20517, 8530, 8530, -2987, + 294, 69663, 20517, 20517, 20517, 20517, 20517, 20517, 20517, 20517, + 45918, 1628, 171, 64713, 20517, 20517, 1549, 881, -2987, 20517, + 1786, -2987, 1553, 20517, 1641, 896, 20517, 20517, 20517, 20517, + 20517, 20517, 20517, 20517, 20517, -2987, -2987, 28853, 347, 740, + 1890, 1909, -26, 1212, 20517, 1901, 11660, -2987, 1901, -2987, + -2987, -2987, -2987, -2987, 205, -2987, -2987, 1491, 1491, -2987, + 64713, -2987, 54828, 225, 51363, 20517, -2987, -2987, 1562, 1563, + 546, 1619, -2987, -2987, 54828, 38276, 1862, -2987, 357, 1567, + -2987, 43849, 1816, 1862, 1267, -2987, -2987, 26248, 1697, 1863, + 1800, -2987, -2987, 1781, 1785, -2987, 1573, 45267, 21559, 21559, + -2987, 1411, 45045, 1433, -2987, -2987, -2987, -2987, -2987, -2987, + 547, -2987, 54828, 78, 35801, -2987, 1581, 102, -2987, 5415, + 1920, 1883, 1714, 218, 1590, -2987, -2987, 996, 1593, 68673, + 54828, 1882, 1835, 1884, -45, 69663, -2987, -2987, -2987, -2987, + 54828, 64713, 63243, 69168, 47898, 54828, 47403, -2987, -2987, -2987, + -2987, 54828, 1102, 54828, 6396, -2987, -2987, -2987, -2987, 192, + -2987, -2987, -2987, -2987, -2987, 64713, 54828, -2987, -2987, 192, + 64713, 54828, 192, -2987, 1082, 54828, 54828, 54828, 54828, 1208, + 54828, 54828, 819, -2987, -2987, -2987, 22080, 8, 8, 1817, + 13223, 131, -2987, 20517, 20517, 901, 273, 64713, 1778, -2987, + -2987, 770, 1826, 200, -2987, 64713, 1649, 54828, 54828, 54828, + 54828, 54828, 1363, -2987, -2987, -2987, -2987, -2987, 1604, -2987, + 1965, 2116, 1606, 1614, 1978, -2987, 202, 1983, 50868, 159, + 2595, 1986, 1663, 1989, 13744, 2091, 1868, -2987, -2987, 1866, + -2987, 64713, 2141, -2987, 175, -2987, 47403, -2987, 212, -2987, + 1869, 241, -2987, 15307, 20517, -2987, -2987, -2987, -2987, -2987, + -2987, 1195, 29359, -2987, 776, -2987, -2987, 2108, 819, 2108, + 672, -2987, -2987, 2108, -2987, 2094, 2108, -2987, -2987, 69663, + -2987, 7699, -2987, 20517, 20517, -2987, 20517, 1994, -2987, 2146, + 2146, 69663, 25206, 25206, 25206, 25206, 25206, 25206, 213, 1345, + 25206, 25206, 25206, 25206, 25206, 25206, 25206, 25206, 25206, 26769, + 230, -2987, -2987, 786, 2119, 20517, 20517, 2001, 1994, 20517, + -2987, 69663, 1645, -2987, 1653, 1654, 20517, -2987, 69663, -2987, + 54828, 1656, -2, 561, -2987, 1664, 1669, -2987, 1540, -2987, + 810, 847, 54828, 2652, 3454, 3760, -2987, -2987, 20517, 1990, + 3920, 3920, 31840, -2987, 20517, 1670, -2987, -2987, 31840, 2007, + -2987, 3920, -2987, -2987, 36296, 3920, 69663, 825, -2987, 54828, + 69663, 833, 20517, -2987, 15307, 2171, 69663, 2138, 64713, 64713, + 2182, 1677, 1681, 2024, 1764, -2987, 1767, 1769, 1772, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, 69663, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, 1673, 1688, 20517, + 20517, 138, -2987, 7786, 1690, 1693, 5578, -2987, 1696, -2987, + 1682, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, 1702, -2987, + 1694, -2987, 1698, 1709, 1722, 1706, 1707, 54828, -2987, 22601, + -2987, 64713, -2987, -2987, 20517, 20517, 54828, -2987, 1715, -2987, + 1708, 1716, 8076, -2987, -2987, -2987, 239, 769, 8382, 1212, + 2227, 2227, 2227, 5276, -2987, -2987, -2987, 1731, -2987, 25206, + 25206, -2987, 2509, 256, 10618, -2987, -2987, 2058, -2987, 954, + -2987, 1727, -2987, -2987, 1988, -2987, 39763, 45338, 20517, 173, + -2987, 20517, 1549, 20517, 1802, 2227, 2227, 2227, 282, 282, + 239, 239, 239, 769, 1212, -2987, -2987, -2987, 1735, 20517, + 47403, -2987, 1739, 1752, 2077, 1347, 20517, -2987, -2987, 31840, + 1520, -1, 1520, 2024, 8530, -2987, 957, -2987, 957, -2987, + 45045, 54828, -2987, -2987, 1985, 1757, 31840, 1771, 2196, 2181, + 64713, -2987, -2987, 1745, 1901, 1742, -2987, -2987, 1776, 20517, + 1749, 1776, -2987, 1862, 5, 1982, 1202, 1202, 1411, 1987, + -2987, -2987, 1831, -2987, -2987, -2987, 20517, 14265, 1444, -2987, + 1447, -2987, -2987, -2987, -2987, -2987, 1765, -2987, 2035, -2987, + 54828, -2987, -2987, 25206, 2217, 20517, 36791, 2222, 2019, -2987, + -2987, -2987, 1860, 1384, 20517, 2011, -2987, 240, 1775, 2135, + 293, 2089, 64713, -2987, 281, 334, -2987, 755, 2142, 241, + 2144, 241, 47403, 47403, 47403, 843, -2987, -2987, -2987, 819, + -2987, 331, 854, -2987, -2987, -2987, -2987, 1865, 806, 1384, + 202, -2987, -2987, -2987, -2987, -2987, -2987, -2987, 198, 814, + 1384, 1870, -2987, 1872, -2987, 1874, 823, 1384, -2987, -2987, + 1576, 9053, 45045, 522, 131, 131, 131, 15307, -2987, 2016, + 2023, 1795, 45045, 45045, 135, -2987, -2987, -2987, -2987, 1801, + -2987, 210, -2987, 64713, -2987, -2987, -2987, 1778, 1846, 1750, + 54828, 202, 1803, 2268, 1125, 1448, -2987, 1962, 1043, 1676, + -2987, 64713, -2987, 47403, 64713, 54828, 54828, 54828, 63738, -2987, + -2987, -2987, 1804, 1805, -2987, 9, 2031, 2036, 54828, 1844, + 54828, 1379, 2282, 54828, -2987, 858, 17912, 2172, 54828, 1794, + -2987, -2987, -2987, -2987, 64713, -2987, -2987, 45045, -2987, -2987, + 48393, -2987, -2987, -2987, -2987, -2987, 47403, -2987, 819, -2987, + 819, 2057, 64713, 42367, 819, 42862, 819, 1822, -2987, 45045, + 8224, 45045, 2001, -2987, 148, 2146, 1825, 1825, 1825, 4327, + 2167, 215, 1828, 1825, 1825, 1825, 296, 296, 148, 148, + 148, 2146, 230, 852, 49383, 1832, -2987, 45045, 45045, -2987, + -2987, 1824, -2987, -2987, -2987, -2987, 1833, 1836, -2987, -2987, + -2987, -2987, -2987, -2987, 64713, 1238, 1520, -27, -27, -27, + -27, -2987, 54828, 54828, 54828, 45045, 2281, 2159, -2987, -2987, + 3920, 45045, 54828, -2987, 27811, -2987, 54828, -2987, 2179, -2987, + 2267, -2987, 54828, 863, -2987, -2987, -2987, 926, 1838, 1681, + 69663, 931, 955, -2987, 2024, 194, 1843, 1555, 1278, 492, + 1445, -2987, -2987, -2987, 1845, 44749, 20517, -2987, 2209, -2987, + -2987, -2987, 20517, 20517, -2987, 39763, -2987, -2987, -2987, -2987, + -50, -50, 1848, 10618, 44971, -2987, 2155, 8299, 45045, -2987, + 1695, -2987, -2987, 8530, 20517, 1205, 3014, 20517, 1851, 20517, + 2188, -2987, -2987, 1854, -2987, -2987, 69663, 20517, 1861, 2787, + 25206, 25206, 3657, -2987, 6043, 20517, 10618, -2987, 41030, 1840, + 1871, 1817, 18433, -2987, 2061, 1852, -2987, 1990, 131, 1990, + 1867, -2987, -2987, -2987, -2987, 4693, -2987, 20517, 2004, 64713, + 379, 2098, 961, -2987, 381, 38276, 1771, 20517, 247, -2987, + -2987, 1880, -2987, 1776, -2987, -2987, -2987, 2075, -2987, -2987, + -2987, 54828, -2987, 1873, -2987, 35801, 2189, 11139, -2987, 35801, + 54828, 54828, 40266, 2220, -2987, 64713, 64713, 64713, -2987, 64713, + 1878, 1876, 899, 1881, 752, -2987, 1847, 899, 2199, 651, + 1379, 272, 2556, 423, -2987, -2987, -2987, 1938, 54828, -2987, + 64713, -2987, -2987, -2987, -2987, -2987, 47898, -2987, -2987, 39267, + 47403, -2987, 47403, 54828, 54828, 54828, 54828, 54828, 54828, 54828, + 54828, 54828, 54828, 1195, 20517, -2987, 20517, 1887, 1891, 1892, + 1817, -2987, -2987, -2987, 223, -2987, 1889, -2987, -2987, -2987, + 257, -2987, 210, 1885, 1894, -2987, 50868, 2426, 1663, 2338, + 1846, 767, 64218, -2987, 1895, 1879, 1750, 963, 965, 202, + 1897, 2340, -2987, 159, 50868, -2987, -2987, -2987, 2297, -2987, + 704, 209, -2987, 1125, -2987, 2426, 1448, -2987, 2426, 45045, + 64713, 1932, -2987, 241, 971, -2987, -2987, -2987, -2987, -2987, + 64713, 1899, -2987, 1899, -2987, -2987, 1899, -2987, -2987, -2987, + -2987, 25206, 2238, 1905, 69663, -2987, -2987, 54828, -2987, -2987, + -2987, 1000, 1900, 1990, 54828, 54828, 54828, 54828, -2987, -2987, + -2987, 18954, 20517, 1946, -2987, 1907, 12181, 2225, -2987, 27290, + -2987, -2987, 1913, 36296, 64713, -2987, -2987, -2987, -2987, 2024, + -2987, -2987, 64713, -2987, 1922, -2987, 1923, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, 20517, 45045, -2987, 45045, + -2987, -2987, -2987, -2987, -2987, 7353, -2987, 1919, 1925, 64713, + 20517, -2987, -2987, -2987, 773, 20517, 20517, 2509, -2987, 45429, + 20517, 69663, 1002, 2509, 348, 20517, 5175, 5705, 20517, 20517, + 6302, 40305, -2987, 23122, 14786, -2987, 1926, 20517, 40344, 38771, + -2987, 31840, 2159, 1927, 2159, 819, 1931, 45045, 20517, -2987, + -2987, -2987, -2987, 1991, 67, 33325, 2149, -2987, 1944, 64713, + -2987, 2004, 45045, -2987, -2987, 39763, -2987, -2987, -2987, -2987, + -2987, 2389, 2000, 1935, 1937, -2987, 1365, -2987, -2987, 64713, + 1939, -2987, 1940, 899, -2987, 64713, 1980, -2987, 309, 2253, + 95, -2987, 20517, -2987, 2343, 2421, 1847, 1950, 64713, 54828, + 25206, -2987, 414, 246, -2987, 2241, 54828, 1980, 2380, -2987, + -2987, -2987, 752, -2987, 2279, 2194, -2987, 192, -2987, 20517, + 752, 2195, 222, 64713, -2987, -2987, 3395, -2987, 69663, 241, + 241, -2987, 1499, 1963, 1964, 1966, 1967, 1968, 1969, 1972, + 1973, 1975, 1997, -2987, 2003, 2005, 2006, 2010, 2012, 2013, + 2015, 2017, 1513, 2018, -2987, 2020, 1880, 2022, 2025, 2028, + 2030, 2032, 70623, 2034, 2045, 2047, 2048, 1514, 2050, 1143, + 1201, -2987, -2987, -2987, -2987, -2987, -2987, 1164, 2051, -2987, + 1998, -2987, -2987, -2987, 2053, -2987, 2074, -2987, -2987, -2987, + -2987, -2987, -2987, 1993, 2014, -2987, -2987, -2987, 131, 1992, + 1995, 64713, 1195, 113, 47403, 64713, 2055, 1844, 2438, 19475, + 1048, 2258, 2021, -2987, 819, 2037, -2987, 1663, -2987, 50868, + 2948, 245, 2036, -2987, 304, 1844, -2987, 2442, 1663, 2092, + 2533, -2987, 2286, 64713, 2065, -2987, -2987, 48393, 1899, 5624, + 25206, 69663, 1027, 1032, -2987, 2573, 2232, 2159, -2987, -2987, + -2987, -2987, -2987, 2072, -29, 2073, 10097, 2076, -2987, -2987, + -2987, -2987, -2987, -2987, 45045, 45045, 64713, 2255, -2987, -2987, + 2082, 2078, 37286, 2536, 2086, -2987, -2987, 2408, -2987, 30353, + -2987, 1681, 2095, 1681, 69663, 1681, -2987, -2987, 45045, 20517, + -2987, -2987, 41298, 2416, 2509, 2509, 45429, 1057, -2987, 2509, + 20517, 20517, 2509, 2509, 20517, -2987, 9575, 550, -2987, 1059, + -2987, 40391, -2987, 71103, -2987, -2987, 1946, 819, 1946, -2987, + -2987, 2093, -2987, -2987, -2987, 2150, -2987, -2987, 1061, 2519, + 2004, 20517, -2987, -2987, 2099, 35801, -2987, -2987, -2987, -2987, + 35801, 899, -2987, 2269, 1980, 2106, -2987, -2987, -2987, -2987, + -2987, -2987, 40430, -2987, 83, 20517, -2987, 184, 4327, -2987, + -2987, -2987, -2987, 1980, 1125, -2987, 54828, 2583, 2472, -2987, + -2987, 45045, -2987, -2987, 2024, 2024, -2987, -2987, 2267, -2987, + -2987, 2110, -2987, -2987, 1164, 375, 39267, 54828, 54828, -2987, + -2987, 2112, -2987, -2987, -2987, -2987, -2987, 257, 2504, 1069, + 1070, 159, -2987, 2426, 2426, 45045, 54828, 2478, 50868, -2987, + 47403, 2591, 2117, 54828, 1844, 437, 437, -2987, 2271, -2987, + 2273, -2987, -2987, 2593, 356, -2987, 19996, 54828, -2987, -2987, + 32830, -2987, 5624, 1071, -2987, -2987, 2120, 2127, -2987, 1946, + 20517, 2128, 20517, -2987, 23643, 2603, 2126, -2987, 20517, 2191, + 28332, -2987, 20517, -2987, 54828, 59778, 2133, 59778, -2987, -2987, + -2987, -2987, -2987, 20517, -2987, 2509, 2509, 2509, 20517, -2987, + 20517, -2987, -2987, -2987, 2339, 2255, -2987, 2255, 20517, 2426, + 381, 2758, 64713, 0, -2987, 45045, -2987, -2987, -2987, 54828, + -2987, 47403, -2987, 899, 12, 2136, 20517, 40780, 2379, -2987, + -2987, 2411, -2987, 2470, -2987, 2212, 640, 2228, -2987, -2987, + -2987, -2987, 1195, 819, -2987, 1663, 2036, 2092, -2987, 2154, + 54828, 1106, 2426, 159, 704, -2987, -2987, -2987, -2987, -2987, + -2987, -2987, -2987, -2987, -2987, -2987, -2987, -2987, 2426, 2596, + 2377, 2597, 2426, 45045, 1932, 20517, 91, -2987, 1110, 2592, + -2987, -2987, 2665, 2255, 2161, 23643, 2163, -2987, 2169, 64713, + 45045, 2313, -2987, -2987, 2173, -2987, -2987, 20517, -2987, 41380, + 2174, 2176, 2625, 1817, 2191, 2191, -2987, 67, -2987, -2987, + 2598, 32830, 2553, 1125, 899, 2187, 1137, -2987, -2987, -2987, + -2987, -2987, 202, -2987, 40866, 2420, 208, 2404, 2136, 20517, + -2987, 2256, -2987, -2987, -2987, 2656, -2987, -2987, 50868, 2184, + -2987, 2092, 2036, 1844, 2092, 2407, -2987, 2409, -2987, 2186, + 40905, 64713, 64713, 1663, 32830, 64713, 2190, 2191, -2987, 2197, + -2987, -2987, -2987, 53838, -2987, 2198, -2987, -2987, -2987, 20517, + 152, -2987, -2987, 2244, 54828, 1145, 40, 2411, 39267, -2987, + 47403, 1058, 12, 2500, -2987, -2987, -2987, -2987, 127, 2417, + -2987, 2422, -2987, 45045, -2987, 2426, 50868, -2987, -2987, -2987, + -2987, -2987, -2987, 32830, 2592, -2987, 357, -2987, 1520, -2987, + 357, -2987, -2987, -2987, -2987, -2987, 1462, 24164, 24164, 24164, + 2201, 2426, -2987, 1520, -2987, 2323, 2404, -2987, -2987, -2987, + -2987, -2987, 176, 176, 2588, -2987, 2266, -2987, 2092, 1146, + 64713, 1776, -2987, 1776, 25727, 2355, 177, 43927, 2575, -2987, + 2575, 2575, -2987, -2987, -2987, 38276, -2987, -2987, 2696, -2987, + 231, -2987, -2987, -2987, 1663, 357, -2987, -2987, 2688, -2987, + -2987, -2987, -2987, -2987, 196, -2987, -2987, -2987, 1520, 899, + -2987, -2987, -2987, 1520, 1776, 24685, 2361, -2987, 2430, -2987, + -2987, -2987, -2987, -2987, -2987, -2987 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = { - 0, 48, 49, 50, 750, 751, 1829, 1776, 2924, 1222, - 1766, 1346, 752, 2586, 2587, 2588, 2230, 1203, 3356, 2231, - 1204, 1205, 2590, 54, 55, 56, 114, 1234, 753, 754, - 527, 59, 2280, 917, 801, 1092, 803, 1093, 1599, 905, - 1237, 1238, 755, 2628, 2292, 3151, 2677, 3152, 2353, 2286, - 1356, 2347, 1870, 1810, 1357, 535, 1884, 2678, 2633, 1871, - 756, 2575, 2926, 3349, 2601, 3489, 2862, 2863, 3346, 3347, - 2578, 2233, 3416, 3417, 2660, 1757, 3411, 2311, 3288, 2237, - 2218, 2864, 2319, 3247, 2972, 2234, 2844, 2312, 3342, 1845, - 2313, 3343, 3100, 2314, 1807, 1833, 2579, 3418, 2238, 1808, - 2574, 2927, 1745, 2315, 3353, 2316, 546, 2848, 757, 2663, - 1302, 529, 518, 519, 1527, 715, 1278, 716, 758, 935, - 1839, 759, 1295, 1821, 65, 1309, 547, 1842, 760, 1830, - 761, 2647, 2648, 762, 763, 1139, 2531, 2152, 764, 741, - 742, 952, 1326, 743, 71, 1850, 765, 1332, 1333, 960, - 73, 870, 1348, 766, 1349, 1350, 969, 74, 2679, 971, - 972, 75, 76, 768, 3183, 2987, 1311, 1846, 2324, 548, - 769, 2809, 2154, 2534, 3338, 79, 3081, 2157, 1164, 3084, - 3302, 2802, 3079, 2535, 3378, 3433, 3082, 2158, 2159, 3303, - 2160, 770, 818, 1467, 771, 772, 1034, 2008, 773, 1748, - 774, 1094, 86, 87, 1007, 88, 3094, 89, 90, 1723, - 1724, 1725, 848, 860, 861, 2150, 1440, 1954, 853, 1168, - 1692, 835, 836, 2276, 878, 1799, 1687, 1688, 2163, 2542, - 1716, 1717, 1177, 1178, 1942, 3317, 1943, 1944, 1433, 1434, - 3192, 1704, 1708, 1709, 2184, 2174, 1695, 2422, 3010, 3011, - 3012, 3013, 3014, 3015, 3016, 1095, 2716, 3203, 1712, 1713, - 1180, 1181, 1182, 1721, 2194, 92, 93, 2135, 2518, 2519, - 807, 3027, 1457, 1726, 2720, 2721, 2722, 3031, 3032, 3033, - 808, 1002, 1003, 1026, 1021, 1447, 1962, 809, 810, 1919, - 1920, 2391, 1028, 1956, 1972, 1973, 2728, 2444, 1528, 2219, - 1529, 1530, 1987, 1531, 1096, 1532, 1558, 1097, 1563, 1534, - 1098, 1099, 1100, 1537, 1101, 1102, 1103, 1104, 1551, 1105, - 1106, 1575, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, - 1997, 1998, 1999, 2000, 2001, 1150, 1727, 1108, 1109, 1110, - 1111, 1112, 1113, 812, 1114, 1115, 1648, 2129, 2517, 3020, - 3200, 3201, 2793, 3069, 3229, 3329, 3448, 3476, 3477, 3503, - 1116, 1117, 1593, 1594, 1595, 2022, 2023, 2024, 2025, 2123, - 1642, 1643, 1118, 2931, 1645, 2045, 3023, 3024, 1151, 1426, - 1586, 1280, 1281, 1542, 1400, 1401, 1407, 1894, 1415, 1419, - 1924, 1925, 1427, 2091, 1119, 2016, 2017, 2461, 1553, 1120, - 1236, 1598, 2788, 2126, 1646, 2085, 1127, 1121, 1128, 1123, - 1582, 1583, 2478, 2760, 2761, 2055, 2191, 1675, 2196, 2197, - 956, 1124, 1125, 1126, 1282, 522, 1543, 3434, 1322, 1156, - 1283, 2081, 775, 106, 776, 96, 777, 1146, 857, 1147, - 1149, 778, 829, 830, 779, 842, 843, 1469, 1662, 1470, - 866, 101, 102, 1191, 831, 849, 781, 3178 -}; - -/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule whose - number is the opposite. If YYTABLE_NINF, syntax error. */ + -2987, -2987, -2987, 1875, 79, -2987, -2987, 146, -2987, 982, + -2987, 145, -814, 520, -2987, 86, 3842, 2546, 3549, 66, + -510, -886, -1210, 28, 87, -1138, 4, -2987, -2987, -2987, + -2987, -2987, -494, 211, -2987, -2987, -634, -2547, -583, -2987, + -2913, -2986, -2987, -2987, -727, -2954, -2059, 89, -2987, -2987, + 93, 1, -2096, -2987, -1645, 42, -2092, 94, 892, -2987, + -2555, 98, -883, -1185, -944, -1191, -2987, -123, -2987, 421, + 105, 1560, -2987, 11, -2163, -2858, -597, -2987, -701, -2987, + -353, -2987, -647, -2987, -929, -654, -686, -2783, -1130, -2987, + 1579, -400, -2987, 557, -2987, -2560, -2987, -2987, 551, -2987, + -1165, -2987, -2207, 115, -630, -2562, -2509, -2166, -885, 203, + -636, 179, -2079, -1212, -2987, 568, -2987, -615, -2987, -891, + -2026, 108, -2987, -2987, 1472, -947, -2987, 110, 1510, -2103, + 7, 10, -2987, -2987, -2987, -2987, -2987, -687, 500, -1211, + -2987, 451, -2987, -2987, -2987, -2987, -189, 169, -2252, 2, + 306, -44, -32, -2987, -25, -2987, -2987, -2987, 606, -2987, + -2987, 21, 29, 1657, -2987, -1033, -2987, -1587, 590, -2987, + 1809, 1810, -2136, -858, -68, -2987, 641, -1661, -2094, -643, + 1086, 1639, 1643, 406, -2325, -2987, -569, -2987, -62, -2987, + -2987, 639, 1129, -1560, -1556, -2987, -2175, -2987, -488, -375, + -2987, -2987, -2987, -2987, -2987, -2453, -2798, -642, 1099, -2987, + 1658, -2987, -2987, -2987, -2987, 43, -1510, 2811, 679, -48, + -2987, -2987, -2987, -2987, 107, -2987, 869, -200, -2987, 2046, + -696, -784, 1893, -153, 143, -1739, 41, 2059, 455, -2987, + -2987, 457, -2085, -1407, 409, -284, 866, -2987, -2987, -1221, + -2987, -1880, -1160, -2987, -2987, -673, 1107, -2987, -2987, -2987, + 1933, 2214, -2987, -2987, 2951, 3055, -2987, -896, 3102, 993, + -1029, 1896, -934, 1898, -930, -928, -933, 1902, 1903, 1904, + 1906, 1910, 1911, -1511, 4396, 2674, 2508, -2183, -2987, -2180, + 989, 55, -2987, -1374, 242, -2987, -2987, -2987, -2987, -2662, + -2987, -462, -2987, -456, -2987, -2987, -2987, -1622, -2703, -1652, + -2987, 2157, 797, -2987, -2987, 392, -2987, -2987, -2987, -2987, + -1527, -2987, 5650, 694, -2987, -2024, -2987, -2987, -970, -829, + -733, -999, -1208, -1916, -2987, -2987, -2987, -2987, -2987, -2987, + -1114, -1767, -161, 754, -2987, -2987, 849, -2987, -2987, -2987, + -1722, -2097, -2987, -2987, -2987, 759, 1436, 82, -822, -1600, + -2987, 812, -2357, -2987, -2987, 403, -2987, -620, -1119, -2424, + 2029, 77, -2987, -779, -2510, -2987, -2987, -702, -2617, -1134, + -894, -2987, 111, -2987, 360, 120, -1658, -2987, 14, -2987, + -408, -2987, -2987, -2575, -2987, 123, 124, 2114, -2987, 1092, + -2987, -2987, -2987, -2987, -575, -2987, -632, -628, -2987, -2987, + 18, -898, 1565, -2987, 125, 436, -2987, 917, -2987, 702, + 128, 80, 1546, 129, 1228, -2987, -2987, -2987, 17, -603, + 361, -2987, 1232, -2987, -2987, 1683, 643, 133, -2987, 302, + 22, -2987, -2987, -2987, 97, 2808, 134, 15, -2927, 136, + -2755, -1592, -7, -2987, -2987, -2987, -730, -2987, -2505 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -2044 static const yytype_int16 yytable[] = { - 517, 61, 66, 904, 521, 880, 881, 1221, 77, 714, - 879, 103, 1122, 953, 1290, 1187, 517, 60, 1152, 1022, - 521, 1418, 91, 100, 1780, 2044, 1239, 1393, 865, 1921, - 805, 1779, 520, 69, 713, 2166, 84, 1744, 78, 95, - 1791, 1471, 91, 780, 1292, 1345, 967, 1763, 811, 1676, - 1392, 2537, 1391, 1329, 2133, 883, 1389, 1976, 740, 884, - 813, 1750, 767, 1335, 1577, 2620, 2621, 2622, 2440, 851, - 1852, 1754, 2580, 1826, 847, 1678, 51, 1351, 2547, 2068, - 2069, 2960, 517, 517, 844, 2268, 521, 521, 2536, 1784, - 2520, 52, 2522, 1796, 53, 57, 805, 805, 2672, 863, - 58, 1223, 62, 1227, 819, 1231, 2442, 2929, 63, 2958, - 64, 1352, 1652, 2932, 811, 811, 2976, 1655, 1589, 2501, - 67, 1239, 963, 68, 2573, 70, 813, 813, 2973, 72, - 80, 2759, 81, 82, 968, 2634, 83, 94, 889, 1360, - 897, 97, 1004, 98, 99, 2300, 2137, 1025, 2823, 955, - -1888, -511, 2828, -1319, -515, -1888, 1046, 1898, -2028, -2028, - 2186, 1899, 1900, 3377, 2297, 3170, 1898, 2189, -1260, -1241, - 973, 1900, -1260, 2629, 2394, 815, -1257, -1257, -1879, -847, - -852, 1554, 1555, -1879, -852, 1323, -2019, -2019, -855, 532, - 815, -1888, 1402, -1896, 1046, -1261, 2293, -1896, 1567, 2641, - -855, -2037, -2037, -1258, -1258, -1261, 1659, 2083, 2637, -814, - 3155, 815, 855, 2649, 944, -827, -842, 815, 815, 815, - 2642, -2014, -2014, 3104, 2459, 2083, 2723, 3174, 3485, -524, - 1735, -2039, -2039, 871, 1008, 1339, 1656, 1339, 815, 1009, - 1046, 1746, 1046, -524, 1134, 1605, 1585, 1046, -524, 3263, - 1794, -511, 1782, 815, -515, 1176, 3250, 1608, 3087, 1795, - 1239, 1609, 1610, -227, 2684, 2686, 1746, 2689, -227, 967, - 536, 3460, 1352, 1608, 1179, 874, 2199, 2608, 1610, 1898, - -648, 1541, 1764, 1899, 1900, 1767, 1768, 876, 2104, 999, - 2423, 1323, 1618, -466, 536, 1165, 1755, 1141, 1010, -524, - 3514, 1755, 1323, 2432, 3336, 533, 1608, 2656, 1618, 876, - 1609, 1610, 3070, 2274, 3072, 3139, 1314, 2796, 3452, -524, - 1025, 3115, 1005, 872, 1738, 1938, 1620, 2977, 3, 4, - 3381, 2290, 1004, 537, 3509, -2013, -2013, 1138, 2092, 2406, - 554, 1618, 1620, 2404, 2952, 875, 745, 1353, 1352, 1732, - 1657, 1352, 1352, 1769, 1982, 1315, 1938, 537, 821, 2417, - 2418, 2419, 1728, 1729, 2695, 2093, 2706, 3119, -524, 1011, - 3445, 931, 862, 862, -1099, 1620, 3515, -524, 3101, 3293, - 1559, 1661, -1099, 2120, -1120, 2070, 112, 3498, 2837, 3294, - 2576, 2121, -1120, 2407, 2216, 3412, 1569, 3344, 1836, 3171, - 2130, 1680, 1172, 1608, 3195, 1012, 539, 2816, 2161, 3164, - 932, 2105, 1798, 2367, 3172, 3402, 2512, 3113, 3279, 3496, - 3176, 1013, 2836, 876, 2846, 1774, 3138, 1778, 2106, 1864, - 783, 1014, 782, 2107, 1046, 893, 2795, 3486, 2797, 2013, - -511, 3165, 2148, -515, 2395, 2645, 3262, 1455, 2019, 1775, - 2847, 1496, 3102, 1853, 2217, 1292, 1541, 3468, 2819, 3345, - 3521, 1006, 3362, 1291, 1142, 1015, 1143, 2149, 3516, 113, - -207, 2108, 1620, 1658, 2817, 2573, 2275, 2573, 1174, 1324, - 2094, 3116, 1865, 1867, 1740, 2279, 2754, 1291, 980, 2985, - 2096, 3114, 2978, 2162, 3453, 934, 3510, 1770, 1456, -784, - 1756, 1135, 1693, 2192, 1571, 1756, 1577, 1771, 3467, -511, - 1797, 1016, -515, 541, 3455, 542, 2696, 3193, 1017, 2220, - 2723, 3261, 3487, 945, 3446, 2577, -524, 2282, 3239, 3337, - -668, 3413, 1979, 1316, 1753, 1045, 2408, 541, 1898, 962, - 2405, 545, 1899, 1900, 1541, 3499, -2041, -2041, -2041, 2131, - 2200, 3488, 1671, 3447, 856, 3295, 2044, 2015, 1018, 3425, - 3105, 1681, 873, 2969, 1730, 545, 1753, 2981, 784, 2436, - 919, 1753, 877, 2630, 2631, 2084, 1136, 1019, 2211, 1597, - 3251, 714, 1930, 1731, 1679, 1324, 2775, 1783, 2291, 1040, - 2991, 2983, 953, 2503, 902, 902, 1324, 1854, 903, 903, - 3461, 1741, 2337, 1858, 3173, 3245, 941, 2953, 1554, 1555, - 1694, 858, 2609, 1945, 2524, 3414, 2273, 2693, 2193, 3426, - 2545, 3517, 3000, 3150, 3255, 2186, 2109, -511, 3270, 1965, - -515, 2550, 1780, 1567, -784, 967, 2804, 1550, 1031, 3168, - 1325, 2097, 2317, 2375, 2318, 2929, 1020, 1317, 534, 1032, - 2539, 2932, 2098, 1912, 1913, 1914, 1915, 2671, 2652, -1888, - 2738, 1572, 2136, 2362, -1888, 1915, -511, 1564, -511, -515, - -1319, -515, 1564, 1572, 2343, 2368, 902, -1260, -1241, 3242, - 903, -1260, 3095, 1573, 3243, 2634, 2643, -1879, -847, -852, - 3169, 2805, -1879, 2026, 2027, 1573, 2866, 1574, 3216, 1603, - -1888, 2020, -1896, 530, -1261, 2396, -1896, 2012, 1585, 1576, - 3361, 1862, 2401, 2050, -1261, 2051, 996, 1585, 1557, 1239, - 2064, 1239, 1556, 968, 1562, -842, 1653, 2138, 3029, 3159, - 865, 2047, 993, 3368, 1855, 1774, 1343, 1344, 1343, 1344, - -1099, 2066, 966, 3128, 3129, 3086, 1328, 3145, 2433, 2122, - -1120, 3367, 2433, 1638, 1639, 1640, 1641, 2717, 1144, 1775, - 2065, 833, 814, 1541, -227, -227, 1936, 3437, 1172, 2867, - 91, 780, 1641, 1910, 1911, 1912, 1913, 1914, 1915, 1166, - 2454, 865, 517, 1172, 2995, 2376, 521, 2584, 1173, -592, - 3230, 970, 3232, 517, -592, 2377, 3077, 521, 2273, 104, - 1636, 1637, 1638, 1639, 1640, 1641, 1188, 995, 1565, 1566, - 1559, 2216, 883, 1755, 811, 1755, 884, 2879, 1906, 2602, - 3435, 2707, 2708, 2709, 2710, 811, 813, 1746, 517, 517, - 1569, 2402, 2603, 852, 3078, 2958, 3088, 813, 1747, 2246, - 1377, 1378, 867, 2581, 1174, 2185, 2185, 2327, 105, 2249, - 1572, 517, 2252, 2868, 3493, 3035, 1541, 868, 3037, 1174, - 3039, 3051, 977, 834, 3153, -592, 2004, 3121, 2402, 61, - 66, 2570, 1573, 2244, 2513, 3126, 77, 869, 939, 103, - 536, 1167, 3330, 1140, 3331, 60, 844, 844, 1755, 844, - 91, 100, 2086, 1175, 3165, 517, 714, 1597, 1145, 1277, - 517, 69, 885, 1140, 84, 1352, 78, 95, 1175, 2946, - 2929, 2947, 1153, 3308, -592, 1352, 2932, 1441, 1352, 1746, - 3363, 2618, 1438, 2044, -2010, -2010, 2269, 2270, 2271, 1448, - 1749, 1195, 2619, 3511, 1755, 2411, 1696, 1196, 2303, 1785, - 2208, 1788, 2346, 537, 51, 900, 2475, 3298, 1755, 2336, - 1690, 3248, 1277, 2338, 2582, 815, 2340, 1381, 1382, 52, - 3383, 2766, 53, 57, 1335, 966, 1293, 2245, 58, 2840, - 62, 517, 517, 918, 2348, 3235, 63, 517, 64, 929, - 517, 517, 1697, 517, 517, 517, 517, 2255, 67, 1866, - 1541, 68, 2262, 70, 1046, 91, 780, 72, 80, 517, - 81, 82, 1921, 521, 83, 94, 517, 1696, 1352, 97, - 521, 98, 99, 805, 2607, 3424, 3224, 1756, 3427, 1756, - 805, 2187, 2188, 107, 517, 1277, 1526, 3225, -2041, -2041, - -2041, 811, 1910, 1911, 1912, 1913, 1914, 1915, 811, 3357, - 929, 925, 1197, 813, 2247, 517, 1853, 1780, 1698, 2250, - 813, 930, 1011, 1697, 2356, 2525, 2841, 2545, 2526, 2357, - 2611, 1195, 23, 906, 517, 2355, 2548, 1196, 865, 2359, - 958, 1046, 2361, -208, 2615, 517, 517, 517, 3061, 517, - 517, 3187, 714, 1753, 1608, 1753, 937, 2220, 1012, 2556, - 1939, 2623, 1756, 2400, 874, 1940, 3340, 936, 902, 1699, - -1241, 3280, 903, 1195, 1442, 942, 1812, 1591, -593, 1196, - 1198, 517, 930, -593, 1014, 3491, 2358, 2610, 3391, 1618, - 1195, 1572, 2842, 541, 2843, 962, 1196, 2449, 517, 517, - -2011, -2011, 1684, 1685, 1541, 1691, 884, 884, 1756, 884, - 3398, 3399, 946, 1573, 1337, 1813, 1541, 1338, 931, 1444, - 902, 545, 1756, 1620, 903, 1451, 3281, 1574, 1753, 1572, - 943, 1700, 1589, 517, 875, 3282, 967, 517, 517, 948, - 1699, 2583, 1197, 2584, 2457, 949, 1541, 517, 517, 517, - 3160, 1573, 517, 1541, -593, 947, 862, 932, 2657, 3283, - 2092, 108, 1140, 3439, 2665, 1576, 959, 2493, 1198, 817, - 817, 1526, 109, 2585, 1753, 27, 28, 29, 1607, 1812, - 1929, 1608, 1931, 1932, 1197, 1609, 1610, 2093, 1753, 1541, - 2733, 902, 933, 1541, 2494, 1596, 1035, 1036, 1037, 1541, - 1815, 1197, 1700, -593, 1277, 115, 2124, 110, 980, 531, - 2125, 1018, 876, 1277, -2012, -2012, 1618, 744, 1813, 2491, - 921, 1541, 922, -2041, 1781, 1199, 923, 1435, 924, 1200, - 1443, 3284, 832, -2015, -2015, 1449, 845, 1277, 2521, 1454, - 34, 978, 934, 2044, 3285, 1459, 2412, 2523, 2413, 1463, - 1620, 1129, 1130, 1814, 1132, -2016, -2016, 111, 901, 1526, - 979, 1201, 1195, 1195, 998, 2996, 1820, 1822, 1196, 1196, - 981, 1369, 1370, 1823, 984, 714, 1824, 39, 987, 2850, - 2549, 2549, 1669, 1411, 714, 1670, 1859, -2017, -2017, 1860, - 2718, 1195, 2592, 2725, 2594, 989, 1978, 1196, 1198, 1979, - 1847, 966, 2094, 1815, 1548, 3507, 47, 2095, 2002, 988, - 41, 2003, 2096, 2287, 2495, 2490, 2288, 2350, 714, 2496, - 2351, 44, 2853, 2388, 517, 2414, 2389, 2415, 1957, 91, - 780, 1959, 1202, 2595, 2434, 2597, 1963, 2435, 1027, 1966, - 1198, 1377, 1378, 1869, 1970, 2437, -2041, 2559, 2435, 2930, - 970, 3494, 2833, 3495, 2835, 1225, 990, 1198, 2877, 1200, - 3470, 877, 2640, -2041, 2598, 2870, 2604, 2599, -2041, 2605, - 991, 517, 517, 1197, 1197, 47, 3482, 517, 1169, 517, - 1171, 2834, 992, 521, 517, 517, 517, 517, -2018, -2018, - 993, 1226, 2945, 2668, 3520, 2730, 1979, 1229, 2435, 517, - 517, 1200, 1197, 1030, 2731, 517, -2041, 2003, 517, 521, - 1033, 811, 521, 517, 2955, 517, 517, 521, 1200, 805, - 521, 517, 805, 813, 2869, 521, 2878, 805, 2755, 2756, - 805, 3518, 1038, 1230, 1039, 805, 3519, 811, 2734, 2736, - 811, 2735, 2735, 3286, 1040, 811, 3287, 907, 811, 813, - 1201, 862, 813, 811, -2020, -2020, 1041, 813, 1381, 1382, - 813, 1629, 1202, 2097, 1133, 813, 1137, 2744, 2746, 2747, - 2497, -2021, -2021, 908, 2098, 854, 1148, 1589, 1526, 3253, - 2811, 2498, 1154, 2812, 2857, 3326, 1441, 3327, -2022, -2022, - 2743, 2745, 2742, 2968, 2984, 2741, 2288, 2351, 2989, 2997, - 3052, 2990, 2998, 2003, 1202, 1045, 3188, 536, 1898, 2003, - 517, 517, 1899, 1900, -2023, -2023, 1901, 1902, 1903, 517, - 517, 1202, 3189, -2024, -2024, 2435, 815, 517, 1541, 1198, - 1198, 2005, -1305, 2858, 517, 1155, 91, 2011, 909, 1157, - 892, 1158, 895, 1163, 899, 3219, 1159, 2006, 2003, 2859, - 2009, 3226, 2007, 2010, 1979, 1162, 2737, 2739, 1198, 714, - 1189, -2041, 1170, 517, 1192, 2545, 517, 910, -2025, -2025, - 537, 1526, 517, 517, 517, 517, 517, 517, 517, 517, - 714, 2676, -2026, -2026, 517, 517, 2207, 2253, 1190, 517, - 1200, 1200, 3236, 517, 1194, 3237, 517, 517, 517, 517, - 517, 517, 517, 517, 517, 2080, 2133, 517, 3269, 1193, - 911, 2288, 967, 1206, 517, 2260, 1277, -2027, -2027, 1200, - -524, 1011, 1201, 2254, 961, 1856, 2168, 1857, 3132, 2064, - 884, -2029, -2029, 3273, -524, 517, 2351, 3305, 536, -524, - 2003, 1207, 3374, 3379, 3096, 2351, 3380, 14, 15, 1233, - 2860, 2261, 2877, 3406, -2030, -2030, 3407, 1012, 517, 2861, - 1224, 1541, 3451, -1305, 3492, 3380, 1228, 3380, -2041, 517, - 517, -2031, -2031, 1450, 1232, 1636, 1637, 1638, 1639, 1640, - 1641, 1288, 1145, 1014, -2032, -2032, -2033, -2033, -2034, -2034, - -524, 1285, 23, 1202, 1202, 1904, -2036, -2036, -2038, -2038, - 540, 537, 23, 1896, 1897, 1526, 1289, 2827, 1294, 1917, - -524, 1352, -2040, -2040, 714, 1310, 714, 1541, 1905, 1800, - 1801, 1296, 1202, 1297, 1982, 2951, -643, -643, 2979, -647, - -647, 3149, 1312, 2963, 1313, 912, -646, -646, 1320, 2232, - 1321, 2236, 1379, 1380, 2988, 1327, 913, 1381, 1382, 3469, - 541, 1330, 962, 3471, 1331, 2302, 517, 3092, 3093, -524, - 1277, 3478, 3479, 517, 517, 1336, 3063, 3304, -524, 543, - 3504, 3505, 1664, 1665, 1354, 544, 1355, 1358, 545, 1429, - 1361, 914, 1416, 1431, 1432, 3215, 1439, 1445, 1906, 1446, - 1452, 1462, 1453, 1544, 1458, 1464, 1545, 1547, -818, -825, - 1556, 1277, 1560, 47, 915, -668, -669, -815, -816, 3512, - 1018, 1570, -819, 1571, -817, 1581, 714, 1590, 1600, 1602, - 1541, 1647, 1663, 1277, 517, 1649, 1651, 1672, 1673, 1443, - 2545, 916, 966, 1682, 1683, 27, 28, 29, 1677, 1175, - 2321, 3036, 1173, 1718, 2424, 27, 28, 29, 1720, 1526, - 2427, 1722, 1733, 517, 517, 1751, 517, 1752, 1758, 1753, - 1759, 1526, 517, 517, 517, 517, 517, 517, 1760, 1765, - 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, - 1772, 541, 1773, 962, 1777, 517, 517, 2930, 1787, 517, - 112, 1526, 1793, 1803, 1804, 1805, 517, 1809, 1526, 1818, - 34, 1819, 1817, 1008, 1828, 1831, 544, 1832, 1009, 545, - 34, 36, 1834, 3124, 1835, 1541, 1837, -524, 517, 1838, - 3304, 517, 1840, 517, 1841, 521, 975, 517, 817, 1848, - 1849, 521, 3267, 38, 1526, 805, 1853, 39, 1526, 1861, - 517, 805, 1277, 1887, 1526, 1889, 1890, 39, 1958, 1926, - 3133, 3134, 1892, 811, 1895, 1955, 1964, 1937, 1029, 811, - 1918, 1927, 1934, 3304, 1969, 813, 1526, 1010, 920, 3034, - 41, 813, 1967, 927, 1968, 1977, 928, 517, 517, 1352, - 41, 44, 1974, 1131, 1352, 902, 1980, 1985, 1157, 903, - 1550, 44, 1541, 1557, 1986, 1562, 1046, 45, 1907, 1908, - 1909, 1981, 1910, 1911, 1912, 1913, 1914, 1915, 3210, 1983, - 1589, 2015, 1984, 3304, 2014, 2048, 2049, 517, 1608, 2057, - 2054, 46, 517, 517, 2082, 2059, 2060, 2061, 2062, 2089, - 2100, 1865, 1867, 23, 2212, 47, 2103, 2101, 1011, 2127, - 865, 2128, 2134, 3359, 2221, 47, 2224, 517, 517, 2235, - 2146, 2028, 517, 2147, 2151, 2239, 875, 2241, 2029, 2030, - 2164, 2806, 2031, 2032, 2033, 2167, 517, 2176, 2177, 517, - 2248, 517, 3320, 2178, 1012, 2251, 2179, 2181, 2180, 2256, - 2257, 2258, 2259, 2198, 2263, 2264, 2202, 517, 714, 2203, - 1013, 14, 15, 3110, 517, 2213, 2206, 517, 2209, 1541, - 1014, 521, 2214, 2215, 2285, 2289, 876, 2328, 2304, 2294, - 2306, 805, 2307, 2308, 517, 23, 1347, 2330, 521, 2322, - 2323, 2325, 2329, 2332, 2331, 1387, 2333, 517, 805, 811, - 2335, 2352, 2339, 1541, 1015, 2360, 23, 1923, 2390, 1898, - 1922, 813, 2397, 2398, 517, 517, 811, 2399, 2403, 2409, - 2410, 2421, 2930, 2426, 2428, 1960, 2439, 2441, 813, 2446, - 2455, 517, 2447, 517, 2448, 3333, 2450, 2451, 2452, 2453, - 2456, 2463, 517, 2466, 1466, 2464, 27, 28, 29, 2468, - 1016, 1780, 3256, 2471, 2467, 2469, 2472, 1017, 2492, 2470, - 714, 714, 714, 2487, 2369, 2370, 2371, 2372, 2373, 2374, - 2508, 2499, 2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, - 2386, 2387, 1541, 2473, 2509, 2232, 2232, 2232, 2474, 2484, - 2485, 2514, 2515, 2516, 986, 2527, 2528, 1018, 2530, 517, - 2532, 2533, 2538, 2540, 2541, 1277, 1533, 1865, 1867, -649, - 1601, 34, 2551, 2554, 2555, 2558, 1019, 2807, 2552, 1352, - 1604, 2562, 2564, 2566, 2563, 865, 1541, 967, 27, 28, - 29, 2569, 2568, 2572, 1820, 1822, 2606, 2591, 1654, 2593, - 2627, 1823, 2612, 1526, 1824, 2613, 2614, 1660, 39, 27, - 28, 29, 2626, 2624, 2625, 2639, 2644, 2638, 2655, 2654, - 2662, 517, 2658, 2659, 714, 2666, 536, 2673, 2683, 2691, - 2694, 2697, 2700, 1161, 2701, 2702, 2703, 2714, 966, 2715, - 2726, 41, 3322, 2727, 714, 1020, 2732, 2751, 2763, 1869, - 1961, -1305, 44, 34, 3309, 2773, 3311, 2064, 2740, 1045, - 2748, 2757, 1898, 2774, 2544, 2771, 1899, 1900, 45, 1869, - 1901, 1902, 1903, 2787, 34, 2777, 2786, 23, 2792, 2794, - 1286, 2798, 517, 3319, 2801, 36, 521, 2768, 1541, 537, - 39, 2820, 46, 2824, 2818, 1299, 1301, 1304, 1306, 2822, - 2832, 2838, 2839, 2865, 2845, 2881, 47, 38, 2948, 2488, - 2489, 39, 2949, 2950, 811, 2961, 2971, 2957, 2975, 3321, - 2954, 517, 3324, 41, 2962, 2724, 813, 3444, 2966, 2967, - 2970, 2986, 2288, 3404, 44, 2993, 1526, 2789, 2994, 3025, - 2999, 1533, 3019, 538, 41, 3021, 3030, 3040, 1405, 3076, - 45, 3041, 517, 3043, 3044, 44, 3064, 865, 517, 517, - 3408, 3397, 539, 3071, 3074, 3083, 3085, 3089, 3090, 517, - 3091, 45, 3097, 1856, 46, 3098, 3103, 3107, 3099, 3108, - 517, 3117, 3109, 517, 3120, 517, 3122, 3123, 2808, 3127, - 865, 1208, 1526, 517, -2009, 46, 517, 517, 3156, -2010, - 3392, 517, 517, -2011, -2012, 3143, 3140, 3141, 517, 47, - -2013, 1209, 3161, 3175, -2014, 3177, 3179, 3190, 3142, 540, - 27, 28, 29, 517, 516, 528, -207, -2015, 1868, 1533, - 552, -2016, 1466, 517, 3181, 3146, 552, -2017, -2018, -2020, - 802, 2826, 816, 816, 1352, 2005, -2021, 820, 552, 828, - 91, 2011, 828, 517, -2022, 846, 850, 1210, -2023, 850, - -2024, 2006, 552, 552, 2009, 3147, 2007, 2010, -2025, 541, - 2810, 542, 1905, -2026, 2034, 2035, 2036, -2027, 2037, 2038, - 2039, 2040, 2041, 2042, -2029, 34, -2030, -2031, 543, 3144, - -2032, 3191, 714, -2033, 544, 2928, 714, 545, 714, -2034, - -2035, -2036, -2037, -2038, -2039, -2040, 802, 802, -1258, 3154, - 517, 3198, 517, 3162, 3180, 3202, 3184, 2232, 3194, 846, - 3205, 2933, 39, 2236, 850, 552, 850, 850, 850, 3196, - 3204, 3208, 3209, 3211, 3218, 3214, 3233, 3234, 3238, 3241, - 3244, 3246, 1906, 3258, 1820, 1822, 3259, 2661, -1257, 3432, - 3266, 1823, 1211, 1541, 1824, 41, 1208, 1734, 3268, 3275, - 3276, 3277, 3292, 3290, 3291, 1195, 44, 3306, 3313, 3307, - 1761, 1196, 3316, 3328, 3310, 2959, 1209, 3323, 3348, 1208, - 3314, 3116, 45, 3354, 3352, 3355, 3358, 517, 3370, 3371, - 1526, 1786, 3372, 3364, 3382, 3377, 3384, 3386, 3389, 1209, - 865, 1212, 2980, 3067, 3394, 2982, 46, 517, 517, 3390, - 1438, 1213, 517, 3395, 3396, 517, 3401, 3403, 3405, 2724, - 47, 3410, 1210, 1214, 3422, 3421, 3415, 3438, 3423, 3449, - 3428, 3430, 1607, 3429, 3440, 1608, 3442, 3459, 3443, 1609, - 1610, 3462, 517, 3464, 3480, 1210, 3460, 3483, 1533, 1208, - 3461, 3497, 3502, 3508, 1811, 1215, 517, 3513, 3522, 3523, - 1827, 517, 517, 1160, 3130, 2880, 517, 1526, 2589, 1209, - 1618, 517, 1535, 85, 517, 517, 1197, -2041, 2240, 517, - 1277, 2884, 2143, 517, 2616, 2283, 2635, 517, 904, 865, - 1789, 521, 2680, 85, 517, 976, 804, 3185, 3419, 3490, - 3254, 805, 3458, 2956, 1620, 3465, 3484, 1217, 1743, 3289, - 2571, 85, 2596, 2974, 2849, 1210, 1195, 1211, 3456, 811, - 864, 3463, 1196, 2567, 2934, 3454, 1816, 2814, 2779, 2780, - 1208, 813, 1218, 1851, 2675, 2139, 2341, 1863, 517, 3375, - 1211, 1533, 3335, 2813, 3436, 3400, 517, 3506, 2799, 2557, - 1209, 1220, 1907, 1908, 1909, 2543, 1910, 1911, 1912, 1913, - 1914, 1915, 804, 804, 882, 517, 1212, 1436, 1674, 2500, - 1437, 2205, 1885, 1715, 1526, 85, 1213, 2705, 3441, 2553, - 2173, 3385, 3312, 2204, 2873, 806, 1714, 2529, 1214, 1212, - 2829, 2830, 1719, 3028, 2431, 3213, 1210, 983, 1403, 1213, - -2041, 2699, 1953, 997, 2698, 2729, 3260, 2445, 2928, 1388, - 1211, 1214, 2349, 1390, 1394, 3388, 3387, -2041, 2882, 2482, - 1215, 1395, -2041, 1396, 1397, 1398, 1399, 1197, 2753, 2460, - 2546, 2506, 1198, 2935, 2936, 2937, 2938, 2939, 2940, 2941, - 2942, 2943, 2944, 1215, 2504, 2483, 2765, 1535, 2142, 3075, - 2438, 890, 1946, 0, 517, 714, 0, 0, 0, 1212, - -2041, 0, 0, 2265, 0, 0, 3457, 0, 0, 1213, - 0, 0, 1217, 0, 0, 1533, 2281, 2281, 0, 0, - 1869, 1214, 0, 966, 0, 0, 517, 1526, 0, 1216, - 865, 1211, 0, 1200, 0, 1217, 0, 1218, 0, 0, - 0, 0, 517, 1208, 0, 0, 0, 3167, 0, 0, - 0, 0, 0, 1215, 0, 1629, 1220, 0, 0, 2992, - 1218, 0, 1277, 1209, 0, 1219, 0, 0, 0, 0, - 0, 1526, 0, 0, 0, 1535, 517, 0, 0, 1220, - 1212, 0, 0, 1347, 0, 0, 0, 517, 517, 2354, - 1213, 517, 850, 517, 0, 0, 0, 850, 0, 0, - 850, 0, 1214, 0, 0, 1217, 0, 0, 552, 1210, - 2871, 0, 0, 0, 0, 0, 0, 0, 517, 0, - 2872, 0, 0, 1198, 0, 0, 0, 0, 0, 0, - 1218, 0, 0, 0, 1215, 0, 1202, 1607, 0, 0, - 1608, 0, 517, 0, 1609, 1610, 0, 0, 1536, 1220, - 0, 0, 0, 0, 0, -2041, 0, 0, 0, 1533, + 520, 58, 70, 865, 54, 877, 904, 68, 1330, 714, + 69, 65, 1223, 1123, 82, 102, 520, 93, 1240, 972, + 1419, 77, 98, 1187, 1794, 1022, 1347, 878, 879, 1153, + 2171, 1747, 1783, 1474, 1294, 1291, 1782, 1679, 772, 953, + 847, 77, 778, 1924, 713, 881, 2049, 1390, 1394, 1766, + 1580, 1392, 882, 1393, 2138, 2527, 1735, 2529, 1981, 740, + 1753, 2657, 517, 2587, 2544, 1336, 805, 1799, 520, 520, + 2447, 1757, 1353, 2968, 2273, 863, 1829, 2554, 811, 51, + 851, 1222, 2508, 1228, 518, 1232, 52, 53, 1787, 56, + 1655, 817, 817, 57, 60, 1658, 2073, 2074, 61, 2937, + 518, 2543, 889, 2982, 2939, 63, 819, 2449, 66, 1004, + 67, 80, 1855, 1240, 1025, 2985, 963, 1592, 805, 805, + 81, 966, 955, 83, 84, 90, 2766, 2641, 91, 92, + 811, 811, 844, 97, 101, -1322, 103, 2966, 2627, 2628, + 2629, 2830, -1244, 2580, -511, 2835, -849, -515, 2142, 2191, + 1361, 897, 518, 518, -1891, 2194, 2298, 1557, 1558, 1901, + 2399, -857, -2031, -2031, 1903, -1263, -2017, -2017, -1891, -1263, + 2299, 3381, -854, -1882, 1570, -1899, -854, -1260, -1260, -1264, + 901, -2022, -2022, -2040, -2040, 815, -1882, -1261, -1261, 1046, + 1663, 1349, -857, -1899, -1264, -816, 1340, 973, 1403, 3177, + -829, 1046, 2649, 1046, -844, 2645, 855, 2643, 1135, 815, + 815, 1196, 3162, 2636, 3110, 815, 2088, 1197, 2088, -2042, + -2042, 2428, 2429, 1659, 1340, 815, 2303, 532, 1142, 1046, + 3181, 1046, 2435, 1176, 1179, 2658, 2439, -466, 1324, 3487, + 972, 1901, 1209, 1797, -511, 1902, 1903, -515, 869, 3462, + 1611, 2730, 1798, 1240, 2731, 1613, 1443, 1588, 2857, 3, + 4, 944, 1210, 872, 1610, 813, 1767, 1611, 1165, 1770, + 1771, 1612, 1613, 3255, 3093, 1324, -227, 2466, 815, 1749, + 1749, -227, 2204, 2691, 2693, 1621, 2696, 1025, 3268, 3340, + 1785, 2615, 999, 1611, 874, -648, 2665, 1612, 1613, 1004, + 3516, 2860, 1621, 874, 1324, 3125, 71, 1901, 1211, -2044, + 2409, 1902, 1903, 1941, 1738, 3454, 2986, 813, 813, 1623, + 3145, 2583, 1198, 2279, -1102, 1758, 71, 1608, 1621, 804, + 2959, 2713, -1102, 873, 1682, 3447, 1623, 1660, 870, 2135, + 1139, 1354, 3500, 533, 71, 2380, 1941, 2702, 3511, 3076, + 3367, 3078, 2802, 864, 2804, 1349, 2197, 1772, 1987, 3201, + 1734, 530, 1623, 1730, 1731, 3121, 2422, 2423, 2424, 1005, + 833, 2295, 2844, 1166, -786, 783, 3517, 2125, -1123, 1172, + 3415, 804, 804, 880, 1562, 2126, -1123, 3405, 1172, 852, + 2075, 1011, 2803, 112, 3175, 1143, 3385, 1144, 2166, 3440, + 1572, 2497, 3171, 1212, -2016, -2016, 71, 2519, 1741, 2221, + 2823, 874, 3144, 3183, 3235, 2843, 3237, 104, 3348, 3285, + 3299, 1801, 1315, 1842, 1568, 1569, 3178, 1012, 1575, 3107, + 3300, 1349, -2044, -511, 1349, 1349, -515, 3334, 1499, 3335, + 921, 3179, 922, 1444, 3427, 3176, 1294, 3430, 3488, -2044, + 1576, 2761, 1213, 1014, -2044, 1174, 2584, 782, 3258, 2826, + 1661, 1316, 1214, 2864, 1174, 1136, 105, 3286, 3518, 2222, + 3172, 2198, 834, 2992, 1215, 1167, 113, 2824, 1199, 3469, + 3349, 2987, 3083, 2167, 3495, -668, 2280, 2381, 2136, 3448, + 814, 3455, -2044, 3366, 1683, 1580, 2580, 2382, 2580, 2703, + 3501, 1773, -511, 3108, 1175, -515, 1216, 2410, 1006, -786, + 3512, 1774, 2865, 784, 3341, 3387, 3416, 1800, 3449, 1574, + 3084, 3470, 3287, 1756, 2225, 3122, 1984, 3266, 2866, 1759, + 858, 3288, 1325, 3489, 3119, 1200, 919, 3313, 3007, 1201, + 1137, 3493, 3250, 3244, 1732, 1733, 2730, 1632, 856, 2731, + 3457, 3111, 2287, 1040, 3199, 3289, 2205, 980, 1218, 1681, + 875, 3260, 3490, 2978, 2975, 1868, 1870, 3156, 1743, 1325, + 945, 1202, 2443, 2990, 2216, 1674, 867, 871, 3463, 2049, + 1018, 714, 1600, 1219, 2089, 1196, 2510, 1557, 1558, 3428, + 2782, 1197, 2278, 2960, 1933, 1756, 3301, 3256, 1325, 1445, + 3417, 3276, 1221, 902, 1553, 2700, 1758, 903, 3120, 972, + 2020, 2998, 1570, 2637, 2638, 1948, 941, 2191, 3429, 953, + -511, 3519, 2557, -515, 1857, 1786, 2616, 3290, 2296, 2867, + 1861, 3180, 1969, 2531, 1575, 2325, 2937, 2326, 2868, 1317, + 3291, 2939, 1203, 2552, 2811, 1783, 2342, -2044, 2650, 902, + 1695, -1244, -1322, 903, 2546, -849, 1576, 2141, 1918, -511, + 2348, -511, -515, -1891, -515, 1575, 2656, 1559, 2367, 1567, + 1577, 3247, 2031, 2032, -1263, 3101, 3248, -1891, -1263, 2641, + 2373, -854, -1882, 1567, -1899, 1744, 534, 1576, -1264, 1145, + -1102, 2724, 3221, 1326, 1606, -1882, 1198, 1344, 1345, 2812, + 3365, 1579, -1899, -1264, 1560, 865, 1865, 2745, 1858, 1565, + 2401, 966, 3159, -844, 1240, 2069, 1240, 2406, 1656, 2143, + 993, 2017, 1588, 3372, 2661, 1344, 1345, 3134, 3135, 3373, + 1329, 1588, 1781, 1777, 1939, 1913, 1914, 1915, 1916, 1917, + 1918, 868, 971, 2127, -1123, 2052, 1458, 2221, 1777, 1644, + 1378, 1379, 996, 1318, -2044, 2440, 865, 1778, 1696, 2440, + 3092, 1639, 1640, 1641, 1642, 1643, 1644, 968, 2873, 77, + 778, 3498, 1778, 1698, 2070, 884, 2278, -227, -227, 2591, + 1611, 2588, 520, 2372, 1611, 2853, 2025, 2461, 3002, 1641, + 1642, 1643, 1644, 520, 536, 2153, 1692, 1459, 2055, 1338, + 2056, 3094, 1339, 1915, 1916, 1917, 1918, 2577, 3438, 2886, + 1759, 2854, 3523, 1188, 2400, 1621, 881, 1562, 2018, 1699, + 2154, 2407, 3151, 882, 815, 2251, 2071, 2024, 520, 520, + 2714, 2715, 2716, 2717, 2609, 2254, 883, 1572, 2257, 3292, + 71, 2874, 3293, 995, 811, 2335, 3127, 2610, 975, 1623, + 817, 520, 1199, 1623, 3132, 811, 1446, 537, 3041, 2966, + 2407, 3043, 1453, 3045, 977, 3057, 518, 1382, 1383, 58, + 70, 2009, 54, 2411, 1146, 68, 1756, 518, 69, 65, + 1029, 2250, 82, 102, 3267, 93, 3160, 900, 1154, 77, + 98, 1856, 2589, 902, 1140, 520, 714, 903, 2937, 1283, + 520, 1600, 2953, 2939, 2954, 1132, 815, 2341, 23, 1226, + -1891, 2343, 1140, 1201, 2345, 2416, 906, 3172, 3281, 3513, + 2520, 2091, 1031, 2213, 107, 2875, 918, 2412, 2351, 2190, + 2190, 2308, 925, 1032, 844, 844, 1701, 844, 2482, 2274, + 2275, 2276, 1436, 3253, 536, 1227, 2361, 51, 2049, 2109, + 2249, 2362, 1283, 1443, 52, 53, 1672, 56, 1439, 1673, + 1462, 57, 60, 971, 1466, 1450, 61, 1293, -208, 1336, + 2260, 520, 520, 63, 2354, 2267, 66, 520, 67, 80, + 520, 520, 2773, 520, 520, 520, 520, 1292, 81, 3240, + 1349, 83, 84, 90, 77, 778, 91, 92, 1702, 520, + 1349, 97, 101, 1349, 103, 1758, 520, 537, 2363, 3401, + 3402, 1196, 2532, 2097, 2533, 929, 1203, 1197, 2847, 1749, + 1924, 946, 1196, 1749, 520, 1283, 1545, 943, 1197, 930, + 1750, 813, 1758, 2097, 1752, 2625, 1346, 541, 930, 962, + 2098, 1862, 813, 865, 1863, 520, 2626, 1388, 1199, 805, + 1758, 27, 28, 29, 71, 864, 805, 937, 1758, 1783, + 2098, 811, 3442, 3229, 520, 545, 942, 1758, 811, 2630, + 2413, 3067, 2110, 2252, 3230, 520, 520, 520, 2255, 520, + 520, 2563, 2552, 518, 714, 3193, 2500, 3344, 1011, 2111, + 518, 947, 108, 1349, 2112, 982, 1469, 2225, 1209, 1575, + 902, 931, -1244, 109, 903, 2848, 994, 2405, 1196, 2590, + 931, 2591, 520, 2501, 1197, 923, 34, 924, 1210, 1598, + 2617, 1576, 1198, 1575, 1012, 1035, 1036, 1037, 1196, 520, + 520, 1788, 2113, 1198, 1197, 1577, 1686, 1687, 110, 1693, + 1452, 2592, 972, 882, 882, 1576, 882, 1867, 1983, 3361, + 1014, 1984, 1046, 39, 880, 2099, 1856, 1451, 1791, 1579, + 2100, 1456, 1604, 520, 1211, 2101, 1592, 520, 520, -2013, + -2013, 2849, 1607, 2850, 71, 2099, 2614, 520, 520, 520, + 2284, 1551, 520, 47, 2618, 2101, 41, 541, 111, 962, + 2464, 1657, 2360, 2622, 948, 2666, 2364, 44, 932, 2366, + 1662, 2674, 1545, 1140, 902, 1869, 2555, 1816, 1599, 1759, + 1046, 1046, 949, 1045, 2456, 545, 1901, 1172, 959, 1198, + 1902, 1903, 1173, 1611, 1904, 1905, 1906, 1612, 1613, 2740, + 2417, 978, 2418, 2502, 1196, 1283, 1759, 933, 2503, 1198, + 1197, 2775, 1942, 979, 1283, -592, 1817, 1943, 813, 980, + -592, 47, 2129, 981, 1759, 813, 2130, 2007, 1621, 1212, + 2008, 1932, 1759, 1934, 1935, 2498, 1784, 2419, 1283, 2420, + 984, 1759, 934, 1130, 1131, 1756, 1133, 1018, 1199, 71, + 1698, 1818, 2599, 2528, 2601, 2292, 987, 2114, 2293, 1199, + 1545, 2355, 1623, 1174, 2356, 988, 1445, 1823, 2049, 989, + 3003, 2393, 1756, 2602, 2394, 2604, 714, 1824, 1213, 990, + 1826, 1827, 804, 2725, 991, 714, 2102, 2732, 1214, 804, + 1756, -592, 935, 3509, -2014, -2014, 1699, 2103, 1756, 998, + 1215, 1819, 971, -2015, -2015, 1230, 2102, 1756, 992, 1201, + 2441, 1850, 1175, 2442, 993, 1198, 2212, 2103, 2444, 714, + 1201, 2442, 1027, 3472, 1552, 520, 1030, 968, 2605, 77, + 778, 2606, 1216, 2840, 2530, 2842, 1564, 1033, 3484, 2611, + -592, 1231, 2612, 2677, 1038, 1199, 1984, 3496, 2737, 3497, + 1039, 2442, 1202, 2566, 1872, 932, -2018, -2018, 2935, 2504, + 1816, 1040, 1700, 1590, 1960, 1199, 1961, 2556, 2556, 1963, + 2505, 2884, 520, 520, 1967, 1041, 2877, 1970, 520, 1971, + 520, 2841, 2952, 1975, 1218, 520, 520, 520, 520, 2648, + 3522, 1871, 1134, 3520, 933, 1469, 1908, 1138, 3521, 1817, + 520, 520, 2258, -2019, -2019, 520, 1201, 520, 23, 1219, + 520, 2738, 1203, 1701, 2008, 520, 2741, 520, 520, 2742, + 520, 2762, 2763, 1203, 520, 2962, 1201, 1149, 1221, 2652, + 2876, 1155, 2885, 1169, 3166, 1171, 1370, 1371, 2259, 1162, + 2743, 1156, 811, 2742, 880, 880, 2818, 880, 2976, 2819, + 2977, 2356, 1158, 2293, 1159, 805, 2996, 805, 1202, 2997, + 805, -2020, -2020, 1160, 518, 805, 1909, 811, 805, 811, + 805, 1199, 811, 1163, 805, 1702, 3330, 811, 3331, 935, + 811, 1545, 811, 1592, 1819, 3004, 811, 3058, 3005, 518, + 2008, 518, 1170, 2748, 518, 2751, 2753, 2754, 2749, 518, + 2750, 2752, 518, 1189, 518, 536, 1378, 1379, 518, 1203, + 536, 1191, 3194, 520, 520, 2008, 1193, 3195, 1194, 2013, + 2442, 2010, 520, 520, 2011, -2021, -2021, 2012, 2265, 1203, + 520, 1195, 1201, 1207, 2015, -1308, 115, 520, 77, 2016, + 531, 1208, 3224, 3459, 3231, 2008, 3241, 1984, 744, 3242, + 1225, 27, 28, 29, 3274, 3275, 3310, 2356, 2293, 2008, + -2023, -2023, 714, 832, 2266, 1229, 520, 845, 537, 520, + -2024, -2024, 1233, 537, 1545, 520, 520, 520, 520, 520, + 520, 520, 520, 714, -2025, -2025, 1234, 520, 520, 2552, + 972, 3370, 520, 1286, 2356, 3383, 520, 1289, 3384, 520, + 520, 520, 520, 520, 520, 520, 520, 520, 2138, 1290, + 520, 1295, 2683, 1297, 71, 1301, 34, 520, 2085, 1283, + 1311, 907, 3409, 1382, 1383, 3410, 1313, 2307, 2069, 813, + 3453, 3494, 2173, 3384, 3384, 1203, 1314, 3138, 520, 882, + 1321, 539, -2026, -2026, 3102, 2744, 2746, 908, -2027, -2027, + 1322, 815, 1328, 39, 813, 1331, 813, -2028, -2028, 813, + 520, 1146, -2029, -2029, 813, 2884, 1332, 813, 1337, 813, + 1355, 520, 520, 813, -2030, -2030, 1910, 1911, 1912, 1356, + 1913, 1914, 1915, 1916, 1917, 1918, 41, 1639, 1640, 1641, + 1642, 1643, 1644, -2032, -2032, -2033, -2033, 44, 1292, 1359, + 2144, -2034, -2034, -2035, -2035, -207, 2995, 1362, 1545, -2036, + -2036, 1417, 909, -2037, -2037, 2834, 1430, 714, 804, 714, + 804, 3155, 1433, 804, -2039, -2039, 1432, 2033, 804, 1440, + 2970, 804, 1987, 804, 2034, 2035, 1448, 804, 2036, 2037, + 2038, 910, 2958, -2041, -2041, 3471, 2192, 2193, 541, 3473, + 542, 47, 2237, 541, 2241, 962, -2043, -2043, 2988, 520, + 1803, 1804, 1447, 1283, 1454, 3069, 520, 520, -643, -643, + 1008, 1467, 14, 15, 1455, 1009, 545, 1461, 544, -647, + -647, 545, -646, -646, 911, 1465, 3309, 1380, 1381, 1547, + 1382, 1383, 1550, 3220, 3098, 3099, 3480, 3481, 3506, 3507, + 1349, 1548, -820, 1045, 3514, -827, 1901, 1283, 1667, 1668, + 1902, 1903, 2329, 1559, -2044, -2044, -2044, 23, 1563, 714, + 47, -668, -669, 71, -817, -818, 1283, 520, 2270, 1573, + -821, 1574, -819, 1584, 1010, 971, 1603, 1597, 1605, 1650, + 1666, 2285, 2285, 1652, 1654, 1675, 1676, 1680, 1685, 1684, + 1173, 2552, 1545, 1175, 1722, 1720, 520, 520, 1724, 520, + 1736, 1754, 1755, 1756, 1545, 520, 520, 520, 520, 520, + 520, 1761, 1762, 520, 520, 520, 520, 520, 520, 520, + 520, 520, 520, 1763, 2430, 1768, 1776, 1780, 520, 520, + 2433, 2857, 520, 1775, 1545, 2935, 1790, 2858, 112, 520, + 1796, 1545, 2095, 3130, 1806, 1011, 1807, 1808, 1346, 912, + 2859, 1812, 3139, 3140, 2359, 1821, 1822, 1815, 1831, 1830, + 913, 520, 1834, 1838, 1837, 520, 1840, 520, 1841, 1843, + 3042, 520, 1844, 1851, 2860, 1852, 2861, 3309, 1856, 1545, + 1864, 1012, 3272, 1545, 1890, 520, 1892, 1283, 1893, 1545, + 1929, 1895, 1962, 1898, 1921, 914, 1930, 1013, 1937, 1940, + 27, 28, 29, 1958, 1968, 1974, 1610, 1014, 1972, 1611, + 880, 1545, 1973, 1612, 1613, 805, 872, 1979, 915, 1982, + 3309, 805, 520, 520, 1553, 1985, 1560, 811, 1991, 1990, + -593, 1565, 2020, 811, -524, -593, 1542, 1986, 1988, 1989, + 2019, 1015, 3040, 1046, 1621, 916, 2053, 2054, -524, 518, + 2551, -2044, 554, -524, 1611, 518, 1592, 2059, 745, 2062, + 865, 2065, 520, 2862, 2087, 34, 2064, 520, 520, 3309, + 821, 3363, 2066, 2094, 2067, 2105, 36, 2106, 1623, 2108, + 2132, 2133, 2139, 2156, 862, 862, 873, 1016, 2152, 873, + 2151, 2172, 520, 520, 1017, 2169, 2181, 520, 38, 2182, + 2183, 2186, 39, 2184, -524, 3325, -593, 2185, 1349, 2203, + 2207, 520, 2208, 1349, 520, 2211, 520, 2214, 2218, 2219, + 2220, 2290, 874, 2294, -524, 2300, 1909, 2311, 2309, 2312, + 2313, 2863, 520, 714, 1018, 41, 2864, 1664, 2314, 520, + 2315, 2336, 520, 2507, 2310, 2316, 44, 893, 2330, 2331, + 1534, 2333, 2337, 1019, 2340, -593, 71, -524, 2357, 520, + 1868, 1870, 45, 2365, 874, 2338, 3116, 1901, 2344, 2395, + 2402, -524, 520, -524, -2044, 1926, -524, 1925, 2403, 2404, + 2426, 2408, -524, 2434, 2446, 2865, 46, 2448, 2414, 520, + 520, -2044, 805, 2415, 2432, 2453, -2044, 2935, 2462, 2454, + 47, 2866, 2457, 2455, 811, 2458, 520, 2459, 520, 805, + 2460, 2463, 1542, 2474, 813, 2470, 2478, 520, 2471, 2476, + 813, 811, 1020, 2477, 2473, 2813, 518, -524, 2475, 2479, + 1783, 2480, 2481, 2491, -2044, 714, 714, 714, 2494, 2499, + 2515, 2492, 2523, 518, 2534, 1610, 2539, -524, 1611, 3261, + 2540, 2506, 1612, 1613, 2537, 2547, -2044, -2044, -2044, 2516, + 2039, 2040, 2041, 2521, 2042, 2043, 2044, 2045, 2046, 2047, + 2237, 2237, 2237, 2545, 520, 865, 2522, 972, 804, 23, + 1283, 2535, -649, 1621, 804, 2548, 2565, 2558, 2562, 1632, + 1622, 2569, 2559, 2561, 2570, 2573, -524, 2576, 2571, 2575, + 1542, 2579, 2867, 2613, 2598, -524, 2600, 2631, 2619, 1823, + 2620, 2868, 2621, 875, 2632, 2607, 714, 1623, 2647, 1824, + 2633, 1545, 1826, 1827, 2651, 2634, 1534, 2646, 2667, 2663, + 2671, -524, 2675, 2664, 2680, 2668, -2044, -2044, -2044, 520, + 1913, 1914, 1915, 1916, 1917, 1918, 2690, 2698, 2701, 2708, + 2721, 1872, 2704, 971, 2722, 2733, 2707, 2734, 2709, 714, + 2739, 2710, 2758, 2770, 2069, 1868, 1870, 2639, 2747, 2780, + 2755, 2799, 2808, 2764, 2793, 2827, 2778, 1349, 2781, 2831, + 2801, 3314, 2839, 3316, 2872, 2653, 2784, 2888, 2969, -2044, + 2980, 813, 2805, 2984, 1872, 2794, 2993, 520, 2829, 902, + 3324, 2846, 1158, 903, 2825, 2852, 2845, 2974, 813, 2964, + 1590, 2814, 2955, 1624, 1534, 2961, 2956, 2957, 2965, 3000, + 2973, 2979, 27, 28, 29, 3006, 1346, 2293, 2095, 3001, + 1625, 3026, 3028, 3032, 2688, 1626, 2689, 520, 3036, 3446, + 2694, 3326, 2697, 3328, 2517, 3046, 3047, 3049, 3089, 865, + 3050, 3070, 3077, 1545, -524, 804, 3080, 3091, 3095, 811, + 3096, 3082, 3097, 2796, 3103, 3104, 3105, 3109, 3407, 520, + 3113, 3114, 804, 1629, 3115, 520, 520, 3123, 3126, 3411, + 3128, 518, 865, 3129, 3133, 3400, 520, 34, 3163, -2012, + -2013, 3147, -2014, -2015, -2016, -2017, -2044, 520, -2018, -2019, + 520, -2020, 520, 1639, 1640, 1641, 1642, 1643, 1644, 1545, + 520, 3146, 3148, 520, 520, 3395, 3149, 3152, 520, 520, + 3153, 1542, 902, -2021, 39, 520, 903, 1610, 1632, -2023, + 1611, -2024, -2025, 2833, 1612, 1613, -2026, 3150, -2027, -2028, + 520, -2029, 3167, -2030, -2032, 3168, -2033, 2013, -2034, 2010, + 520, -2035, 2011, 2817, -2036, 2012, -2037, 41, -2038, 3182, + -2039, 3170, 2015, 516, 527, 1621, 77, 2016, 44, 552, + 520, -2040, -2044, -2041, -2042, 552, -2043, -1261, 3184, 802, + 3161, 816, 816, 3186, 45, 3187, 820, 552, 828, 3190, + 939, 828, 3196, 3197, 846, 850, 3200, 3202, 850, 1623, + 3208, 552, 552, 3211, 3204, 3214, 1209, 23, 46, 714, + 3210, 3215, 2938, 714, 1542, 714, 3216, 3223, 3219, 3239, + 3243, 3238, 2815, 3249, 3246, 864, 1210, 520, 1634, 520, + 3251, 802, 802, 3263, 3264, 1534, -1260, 3271, 3273, 1349, + 3280, 3282, 3283, 3298, 2237, 3311, 813, 3296, 2940, 3297, + 2241, 3312, 3315, 3318, 3319, 3321, 846, 3327, 3332, 2967, + 3352, 1823, -1774, 850, 552, 850, 850, 850, 3122, 3356, + 3358, 1824, 1211, 2878, 1826, 1827, 3359, 3362, 3368, 3376, + 3375, 3377, 3381, 2879, 3386, 2931, 3388, 2989, 3390, 3435, + 2991, 3393, 865, 3073, 3399, -2044, 3406, 3397, 3394, 3398, + 3408, 3404, 3413, 3418, 520, 3424, 3425, 1545, 3426, 3431, + 3433, 3432, -2044, 3451, 3461, 3441, 3464, -2044, 2639, 3485, + 3462, 3466, 3443, 3445, 520, 520, 3482, 3463, 1534, 520, + 3499, 3510, 520, 3504, 3515, 1635, 3524, 3525, -2044, -2044, + -2044, 2880, 1639, 1640, 1641, 1642, 1643, 1644, 1542, 2887, + 27, 28, 29, 1161, 2245, -2044, 2328, 2596, 3339, 520, + 3439, 2891, -1774, 1439, 3403, 2346, 2820, 1212, 3508, 3136, + 2682, 3422, 3492, 520, 3259, 3460, 23, 3467, 520, 520, + 3486, 865, 958, 520, 1545, 1746, 3295, 2578, 520, 2983, + 3458, 520, 520, 3465, 2603, 2574, 520, 1283, 2856, 1590, + 520, 2941, 3456, 1854, 520, 1610, 904, 2642, 1611, -1774, + 1632, 520, 1612, 1613, 1820, 34, 1213, 2687, 3191, 2564, + 2550, 2963, 1677, -1774, 1437, 1438, 1214, 1717, -1774, 2210, + 1716, 2712, 1590, -1774, 3444, 2560, 2178, 3389, 1215, 3317, + 2881, 2209, -1774, 1621, 806, 2536, 3035, -1774, 1721, 3218, + -2044, 71, 39, 2438, 805, 520, 997, 71, 983, 2706, + 2705, 2736, 1534, 520, 3265, 2452, 811, 3392, 14, 15, + 1216, 2353, 3391, 2489, 2553, 2760, 2513, 1623, 2511, -1774, + 2467, 3079, 520, 2832, 1949, 41, 1404, 1389, 518, 1391, + 2490, 1545, 1542, 1395, 1396, 1397, 44, 1398, 862, -1774, + 3081, 1399, 1400, 2772, 1542, 2806, 3379, 976, 2288, 2445, + -2044, 2147, 45, 23, 1866, 1888, 2149, 2821, 890, 27, + 28, 29, 1218, 2623, 0, 2938, 1792, 0, 0, 0, + 0, 0, 0, 0, 1542, 0, 46, 0, 0, 23, + 0, 1542, 2785, 0, 0, 0, 0, 1219, -1774, 0, + 47, -1774, 0, 0, 0, 0, 0, -1774, 0, 0, + 0, 0, 0, 71, 0, 0, 1221, 714, 2882, 0, + 0, 2883, 520, -2044, 0, 0, 1536, 0, 0, 1542, + 0, 0, 865, 1542, 34, 0, 0, 0, 0, 1542, + -2044, 71, 3174, 0, 71, -2044, 0, -1774, 0, 0, + 971, 0, 1872, 520, 1545, 0, 1534, 0, 0, 0, + 0, 1542, 0, 0, 0, 0, 0, -2044, 1534, 520, + -1774, 39, 0, 0, 1639, 1640, 1641, 1642, 1643, 1644, + 0, 0, 1045, -2044, 0, 1901, 0, 0, 0, 1902, + 1903, 0, 1590, 1904, 1905, 1906, 0, 1545, 1534, 0, + 3169, 0, 520, 813, 41, 1534, 27, 28, 29, 0, + 2776, 0, 0, 520, 520, 44, 0, 520, 0, 520, + 0, 3337, 0, 1346, 0, 0, 0, 0, 852, 0, + 1756, 45, 27, 28, 29, 0, 0, 0, 1632, 0, + 0, 850, 0, 1534, 520, 0, 850, 1534, 0, 850, + 0, 0, 0, 1534, 0, 46, -1774, 552, 0, 3173, + 0, 0, 0, 0, 0, 0, -1774, 804, 520, 47, + 0, 34, 0, 0, 0, 1534, 0, 0, 0, 23, + 0, 864, 36, 0, 0, -1774, 0, -1774, -1774, 0, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 2938, + 0, 0, 1536, 3236, 38, 1414, 0, 0, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1533, 2141, 2928, 2144, 1618, 0, 0, 2873, 0, - 2242, 0, -2041, 0, 1200, 2153, 1217, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1538, 0, - 0, 1533, 0, 0, 1211, 0, 0, 0, 1533, 1620, - 0, 1218, 517, 714, 1539, 0, 2243, 517, 3112, 3111, - 0, 521, 0, 2190, 0, 0, 0, 517, 0, 517, - 1220, 517, 3271, 3272, 0, 517, 0, 517, 1869, 517, - 0, 0, 0, 0, 1533, 0, 0, 0, 1533, 811, - 1008, 517, 0, 1212, 1533, 1009, 517, 0, 517, 0, - 0, 813, -2041, 1213, 0, 0, 517, 0, 0, 1636, - 1637, 1638, 1639, 1640, 1641, 1214, 1533, 2874, 0, 714, - 0, 0, 0, 0, 517, 0, 0, 1202, 0, 0, - 0, 0, 0, 0, 1535, 0, 0, 0, 951, 552, - 552, 0, 0, 0, 3341, -2041, 0, 1215, 0, 0, - 3332, 0, 3334, 0, 1010, 0, 2295, 2296, 2298, 2299, - 0, 2301, -2041, 1536, 0, 0, 0, -2041, 0, 0, - 0, 0, 0, 517, 0, 0, 0, 0, 0, 974, - 528, 816, 0, 517, 0, 0, 516, 85, 850, 1540, - 0, 0, 3366, 0, 0, 0, 517, 802, 3186, 1217, - 0, 1001, 1001, 0, 0, -2041, 1001, 1024, 3369, 0, - 517, 0, 3373, 1538, 521, 0, 0, 0, 0, 0, - 828, 828, 828, 0, 1218, 1011, 0, 1535, 517, 1539, - 0, 0, 0, 1183, 828, 828, 0, 828, 0, 0, - 0, 0, 811, 1220, 1362, 2875, 815, 0, 2876, 0, - 850, 1536, 0, 517, 813, 0, 552, 521, 0, 0, - 1629, 1012, 0, 0, 0, 0, 0, 850, 0, 517, - 850, 0, 0, 0, 0, -1771, 0, 1013, 2928, 0, - 714, 0, 0, 0, 0, 811, 0, 1014, 2600, 0, - 0, 0, 2416, 0, 0, 0, 0, 813, 0, 0, - 0, 1538, 0, 517, 0, 3341, 0, 521, 0, 1363, - 1364, 0, 0, 0, 850, 1287, 0, 1539, 517, 517, - 517, 1015, 0, 0, 0, 0, 0, 3257, 0, 850, - 850, 850, 850, 1308, 0, 811, 0, 0, 3466, 0, - 2632, 0, 1184, 0, 0, 517, 1319, 813, 3264, 3265, - 1365, 1366, 0, 0, 1367, 1368, 0, 1753, 2646, 0, - -2041, 1535, 0, 0, 1540, 3481, 0, 1016, 0, 0, - 0, 1008, 0, 3278, 1017, -1771, 1009, 0, 0, 1001, - 1024, 0, 850, 0, 0, 1410, 517, 0, 0, 0, - 0, 1001, 1001, 0, 0, 0, 0, 552, 0, 1347, - 0, 85, 864, 802, 0, 0, 0, 2681, 0, 2682, - 802, 0, 0, 2687, 1018, 2690, 0, 0, 0, 0, - 552, 0, -1771, 1533, 0, 0, 0, 1465, 0, 1369, - 1370, 0, 553, 1019, 0, 1010, -1771, 1546, 553, 0, - 0, -1771, 982, 0, 0, 0, -1771, 0, 0, 0, - 553, 0, 1540, 994, 0, -1771, 0, 0, 0, 0, - -1771, 0, 0, 0, 553, 553, 0, -2041, 0, 0, - 1536, 0, 0, 0, 1636, 1637, 1638, 1639, 1640, 1641, - 0, 0, 0, 0, 0, 0, 0, 0, 552, 0, - 0, 0, -1771, 1371, 1372, 1373, 1374, 1375, 1376, 1377, - 1378, 882, 1020, 1379, 1380, 1535, 1011, 1185, 0, 2320, - 0, 0, -1771, 0, 0, 0, 0, 1535, 0, 0, - 1538, 85, 0, 0, 0, 0, 0, 553, 0, 23, - 0, 0, 1045, 0, 1666, 1898, 1539, 1668, 0, 1899, - 1900, 0, 1012, 1901, 1902, 1903, 0, 1535, 0, 0, - 0, 552, 552, 0, 1535, 0, 1533, 0, 1013, 850, - 2769, -1771, 0, 1536, -1771, 0, 0, 0, 1014, 0, - -1771, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1410, 0, 0, 0, 0, 0, 0, 0, 0, - 1535, 850, 1742, 0, 1535, 1872, 0, 0, 0, 0, - 1535, 0, 1015, 0, 850, 0, 0, 0, 3450, 0, - -1771, 0, 1533, 1538, 0, 0, 1381, 1382, 0, 0, - 0, 850, 1535, 1186, 0, 850, 85, 0, 0, 1539, - 1790, 0, 0, -1771, 0, 2850, 0, 2636, 0, 0, - 0, 2851, 1873, 0, 0, 0, 0, 0, 1016, 0, - 2650, 2651, 2653, 0, 2852, 1017, 2925, 0, 0, 804, - 0, 0, 0, 1874, 0, 2664, 804, 0, 2667, 0, - 0, 1540, 27, 28, 29, 0, 2674, 0, 2853, 0, - 2854, 1875, 0, 0, 0, 1876, 1806, 0, 850, 2632, - 0, 852, 0, 0, 850, 1018, 0, 1536, 0, 0, - 0, 1549, 0, 0, 0, 0, 0, 1877, 1844, 0, - 1878, 1383, 1384, 1561, 1019, 1533, 0, 951, 0, -1771, - 0, 0, 951, 0, 552, 552, 1879, 552, 951, -1771, - 0, 0, 0, 0, 0, 1385, 1386, 34, 0, 0, - 1587, 0, 0, 0, 0, 1905, 0, 1538, -1771, 0, - -1771, -1771, 0, 0, 0, 1465, 0, 0, 0, 0, - 2711, 2712, 2713, 1539, 1540, 0, 0, 2855, 0, 0, - 0, 0, 0, 0, 39, 0, 0, 0, 1654, 0, - 0, 0, 0, 1020, 0, 0, 1045, -1771, 0, 1898, - -1771, -1771, -1771, 1899, 1900, 0, 0, 1901, 1902, 1903, - 0, 0, 0, 0, 0, 1410, 1410, 41, 0, 0, - 1533, 1410, 0, 516, 3054, 1906, 0, 0, 44, 1880, - 0, 882, 882, 0, 882, 0, 1001, 1881, 552, 1941, - 0, 0, 0, 0, 45, 2856, 850, 0, 0, 802, - 2857, 1536, 802, 0, 0, 0, 0, 802, 0, 1882, - 802, 0, 3073, 1536, 0, 802, 0, 552, 46, 552, + 0, 0, 0, 714, -1774, 3277, 3278, -1774, -1774, -1774, + 0, 0, 0, 0, 39, 0, 0, 0, -2044, 520, + 0, 41, 0, 520, 862, 0, 0, 0, 0, 0, + 0, 0, 44, 520, 0, 520, 0, 520, 1872, 0, + 0, 520, 0, 520, 0, 520, 0, 41, 45, 0, + 0, 0, 2931, 0, 0, 0, 520, 0, 44, 0, + 0, 520, 0, 520, 0, 0, 0, 0, 0, 0, + 1536, 520, 46, 0, 45, 1908, 0, 0, 0, 0, + 0, 3336, 0, 3338, 714, 811, 47, 1537, 0, 520, + 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, + 0, 0, 27, 28, 29, 0, 0, 518, 0, 0, + 0, 0, 47, 0, 0, 0, 0, 0, 0, 3345, + 0, 0, 0, 0, 3371, -2044, 71, 951, 552, 552, + 0, 0, 1639, 1640, 1641, 1642, 1643, 1644, 520, 0, + 3374, 0, 0, 0, 3378, 1909, 0, 0, 520, 0, + 0, 1542, 0, 536, 0, 0, 0, 0, 0, 0, + 520, 0, 1590, 0, 0, 0, 0, 34, 974, 527, + 816, 0, 0, 0, 520, 516, 0, 850, -1308, 3364, + 0, 1414, 0, 0, 0, 0, 802, 0, 0, 0, + 1001, 1001, 520, 0, 0, 1001, 1024, 0, 1859, 0, + 1860, 0, 0, 0, 39, 0, 0, 0, 0, 828, + 828, 828, 0, 0, 0, 0, 537, 520, 0, 0, + 0, 0, 1875, 828, 828, 0, 828, 0, 0, 0, + 0, 0, 520, 0, 0, 0, 811, 41, 0, 850, + 0, 2938, 0, 714, 0, 552, 0, 0, 44, 0, + 0, 0, 0, 0, 0, 0, 0, 850, 518, 0, + 0, 0, 0, 1537, 45, 1534, 520, 3468, 0, 1876, + 961, 850, 813, 0, 0, 1209, 0, 0, 3345, 811, + 520, 520, 520, 1542, 0, 0, 0, 0, 46, 0, + 1877, 1536, 0, 3483, -1776, 1210, 0, 0, 0, 0, + 0, 518, 47, 850, 1288, 0, 0, 520, 1878, 71, + 71, 0, 1879, 0, 2931, 1299, 0, 0, 0, 850, + 850, 850, 850, 0, 0, 0, 0, 0, 811, 0, + 0, 0, 0, 0, 1880, 1320, 1413, 1881, 0, 1542, + 0, 1211, 0, 0, 0, 0, 540, 0, 520, 0, + 518, 1537, 0, 1882, 0, 1910, 1911, 1912, 0, 1913, + 1914, 1915, 1916, 1917, 1918, 0, 0, 0, 1001, 1024, + 0, 850, 0, 0, 1411, 0, 0, 0, 0, 0, + 1001, 1001, 0, 0, 1536, 71, 552, 71, 0, 0, + 0, 0, 802, 0, -1776, 0, 541, 1534, 962, 802, + 0, 0, 553, 0, 0, 0, 1414, 1414, 553, 552, + 2880, 0, 1414, 0, 0, 543, 1468, 0, 0, 0, + 553, 544, 0, 813, 545, 0, 1549, 0, 71, 0, + 0, 0, 0, 0, 553, 553, 1212, 0, 0, 0, + 0, -1776, 1542, 0, 71, 0, 1883, 0, 71, 0, + 0, 0, 0, 1534, 1884, -1776, 0, 0, 0, 0, + -1776, 0, 0, 0, 0, -1776, 813, 0, 0, 0, + 0, 0, 0, 0, -1776, 552, 1885, 0, 0, -1776, + 0, 0, 0, 0, 0, 1213, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1214, 0, 553, 0, 0, + 0, 0, 1412, 1886, 0, 1610, 0, 1215, 1611, 0, + 0, -1776, 1612, 1613, 0, 813, 0, 0, 1536, 0, + 0, 0, 0, 1713, 1669, 0, 1671, 0, 0, 0, + 0, -1776, 1413, 0, 0, 0, 0, 1542, 0, 1216, + 0, 552, 552, 1621, 0, 0, 0, 0, 850, 0, + -2044, 0, 0, 0, 0, 0, 1534, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 47, 0, 3166, 0, 1883, 0, 0, 0, - 0, 0, 0, 1536, 0, 0, 0, 1533, 0, 2858, - 1536, 1538, 0, 0, 23, 0, 0, 2821, 1540, 0, - 0, 0, 0, 1538, 0, 2859, 0, 1539, 0, 1045, - 0, 0, 1898, 0, 0, 0, 1899, 1900, 0, 1539, - 1901, 1902, 1903, 0, 0, 0, 1536, 0, 0, 1535, - 1536, 0, 0, 1538, 0, 0, 1536, 0, 0, 0, - 1538, 0, 0, 0, 0, 0, 0, 0, 0, 1539, - 0, 0, 0, 0, 0, 0, 1539, 0, 1536, 0, - 0, 0, 0, 0, 0, 0, 0, 2043, 0, 0, - 553, 0, 0, 0, 0, 0, 1538, 0, 2053, 0, - 1538, 0, 0, 0, 0, 0, 1538, 0, 2965, 0, - 85, 0, 1539, 0, 1533, 0, 1539, 0, 0, 1905, - 0, 0, 1539, 0, 0, 0, 2860, 0, 1538, 0, - 0, 0, 0, 0, 0, 2861, 0, 951, 0, 0, - 0, 3163, 0, 0, 1539, 1907, 1908, 1909, 1533, 1910, - 1911, 1912, 1913, 1914, 1915, 0, 0, 27, 28, 29, - 1607, 0, 1540, 1608, 1347, 0, 0, 1609, 1610, 0, - 3001, 3002, 3003, 3004, 1540, 0, 0, 0, 0, 0, - 0, 0, 1535, 0, 2140, 0, 850, 0, 850, 1906, - 0, 0, 0, 0, 0, 0, 0, 0, 1618, 850, - 2156, 0, 0, 0, 1540, -2041, 0, 0, 0, 0, - 0, 1540, 1410, 0, 0, 804, 0, 0, 804, 2201, - 0, 0, 34, 804, 0, 0, 804, 1533, 0, 0, - 0, 804, 1620, 0, 0, 0, 0, 850, 1535, 552, - 0, 0, 1905, 0, 0, 3231, 0, 1540, 0, 0, - 0, 1540, 0, 1742, 552, 0, 0, 1540, 0, 39, - 0, 0, 0, 0, 552, 2222, 552, 2226, 0, 552, - 0, 1533, 0, 0, 0, 552, 0, 552, 0, 1540, - 0, 553, 553, 0, 0, 0, 0, 0, 0, 951, - 552, 0, 41, 0, 951, 552, 0, 2778, 0, 552, - 552, 552, 552, 44, 552, 552, 0, 0, 0, 0, - 0, 0, 1906, 0, 2925, 0, 0, 85, 0, 45, - 0, 2284, 3118, 0, 0, 0, 0, 0, -2041, 0, - 850, 850, 850, 850, 1308, 850, 0, 0, 0, 0, - 0, 1535, 0, 46, 0, -2041, 0, 0, 0, 2310, - -2041, 0, 0, 0, 0, 0, 0, 47, 0, 0, - 0, 0, 0, 0, 0, 2334, 0, 0, 0, 0, - 0, 0, 0, 1533, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1536, 0, 0, -2041, 0, - 0, 0, 0, 0, 0, 0, 2090, 0, 553, 1907, - 1908, 1909, 0, 1910, 1911, 1912, 1913, 1914, 1915, 0, - 0, 0, 0, 0, 0, 0, 1410, 1410, 1410, 1410, - 1410, 1410, 0, 0, 1410, 1410, 1410, 1410, 1410, 1410, - 1410, 1410, 1410, 1410, 0, 1538, 1535, 0, 0, 0, - 0, 0, 3360, 1629, 0, 0, 0, 0, 0, 0, - 0, 1539, 0, 0, 552, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 882, 850, 0, 0, 0, - 0, 0, 0, 0, 0, 802, 0, 0, 0, 0, - 0, 802, 1045, 0, 0, 1898, 552, 0, 0, 1899, - 1900, 552, 0, 1901, 1902, 1903, 0, 0, 0, 0, - 2443, 2443, 0, 0, 0, 0, 0, 0, 0, 0, - 3055, 0, 0, 1535, 0, 0, 0, 0, 1536, 0, - 0, 0, 1907, 1908, 1909, 0, 1910, 1911, 1912, 1913, - 1914, 1915, 0, 0, 0, 0, 0, 0, 0, 1430, - 0, 0, 0, -2041, 0, 1607, 0, 0, 1608, 0, - 0, 0, 1609, 1610, 0, 0, 0, 0, 0, 0, - 0, 0, 1461, 0, 0, 0, 0, 0, 1538, 552, - 0, 0, 0, 2479, 1536, 0, 0, 0, 552, 2925, - 0, 0, 0, 1618, 1539, 0, 1540, 0, 0, 0, - -2041, 0, 0, 0, 0, 0, 0, 0, 2305, 0, - 0, 1410, 1410, 0, 0, 0, 0, 85, 0, 0, - 0, 0, 0, 0, 0, 0, 3231, 1620, 2043, 0, - 1535, 0, 0, 3274, 1538, 0, 0, 0, 0, 0, - 1592, 0, 0, 0, 0, 0, 0, 0, 1533, 0, - 1539, 0, 0, 0, 3299, 0, 0, 0, 0, 0, - -2041, 802, 0, 0, 1535, 0, 0, 1636, 1637, 1638, - 1639, 1640, 1641, 552, 0, 0, 0, 0, 802, 0, - 0, 0, 2156, 0, 0, 0, 0, 1536, 0, 0, - 0, 0, 2781, 1607, 0, 0, 1608, 0, 0, 0, - 1609, 1610, 0, 553, 553, 1905, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3339, 0, 0, - 0, 0, 552, -2041, 0, 1410, 0, 0, 552, 1540, - 0, 1618, 0, 0, 0, 0, 0, 1538, -2041, 0, - -2041, 804, 0, 1535, 1806, -2041, 0, 804, 3365, 0, - 0, 0, 0, 1539, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1620, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1906, 0, 0, 0, 0, - 0, 0, 1536, -2041, 0, 1540, 0, 1535, 0, 0, + 1411, 71, 1537, 0, 0, 0, 0, 1623, 0, 0, + -1776, 850, 1745, -1776, 0, 0, 0, 0, 0, -1776, + 0, 1218, 0, 0, 850, 0, 0, 71, 0, 0, + -1791, 0, 0, 0, 0, 0, 0, 0, 0, 2217, + 0, 850, 0, 0, 1542, 850, 1219, 0, 0, 2226, + 1793, 2229, 0, 0, 2240, 0, 0, 0, 0, -1776, + 2244, 0, 2246, 0, 0, 1221, 0, 0, 0, 0, + 0, 0, 2788, 0, 0, 2253, 0, 0, 0, 2137, + 2256, 1534, -1776, 0, 2261, 2262, 2263, 2264, 0, 2268, + 2269, 0, 1536, 0, 0, 1537, 0, 0, 0, 0, + 0, 0, 0, -2044, 1536, 0, 1809, 0, 850, 0, + 0, 0, 0, 0, 0, 0, 0, 850, 0, 0, + -2044, 0, 0, 0, 1414, -2044, 0, 0, 1847, 0, + -1791, 0, 0, 0, 1536, 0, 0, 951, 0, 0, + 852, 1536, 951, 0, 552, 552, 0, 552, 951, 0, + 0, 1542, 0, 0, 854, 0, 0, 0, 1534, 0, + 0, 0, 0, -2044, 0, 0, 0, 0, -1776, 0, + 0, 0, 0, 0, 0, 1468, 0, -1791, -1776, 1536, + 0, 0, 0, 1536, 0, 1542, 0, 1413, 1413, 1536, + 0, -1791, 0, 1413, 0, 0, -1791, -1776, 0, -1776, + -1776, -1791, 0, 0, 0, 0, 0, 0, 0, 0, + -1791, 1536, 0, 0, 0, -1791, 0, 0, 1632, 892, + 0, 895, 0, 899, 0, 1411, 1411, 1008, 0, 1537, + 0, 1411, 1009, 516, 0, 0, -1776, 0, 0, -1776, + -1776, -1776, 0, 0, 0, 0, 1001, -1791, 552, 1944, + 0, 0, 0, 0, 1539, 0, 850, 0, 802, 0, + 802, 0, 0, 802, 1542, 1534, 0, -1791, 802, 0, + 0, 802, 0, 802, 0, 0, 0, 802, 0, 552, + 0, 552, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1010, 0, 0, 0, 0, 0, 0, 0, 1534, + 0, 0, 0, 0, 0, 0, 0, 1542, 0, 0, + 0, 0, 0, 0, 0, 0, -1791, 0, -2044, -1791, + 0, 0, 0, 0, 0, -1791, 0, 0, 0, 1414, + 1414, 1414, 1414, 1414, 1414, 0, 0, 1414, 1414, 1414, + 1414, 1414, 1414, 1414, 1414, 1414, 1414, 0, 0, 0, + 0, 0, 0, 1899, 1900, 0, 0, 0, 1540, 1920, + 0, 0, 1011, 0, 0, -1791, 0, 0, 0, 0, + 553, 0, 0, 1537, 0, 0, 0, 0, 1534, 0, + 0, 0, 0, 0, 0, 1537, 0, 0, -1791, 2048, + 0, 0, 0, 0, 0, 0, 0, 0, 1012, 0, + 2058, 0, 0, 0, 0, 1541, 0, 0, 0, 1542, + 0, 0, 0, 0, 1013, 1537, 0, 0, 0, 0, + 0, 1534, 1537, 0, 1014, -2044, 0, 0, 0, 0, + 1539, 0, 1639, 1640, 1641, 1642, 1643, 1644, 0, 951, + 0, 0, 0, 0, 0, 0, 852, 0, 0, 0, + 1859, 0, 0, 0, 0, 0, 0, 0, 1015, 0, + 1537, 0, 0, 0, 1537, 0, 0, 0, 0, 0, + 1537, 0, 0, 0, -1791, 2180, 0, 0, 0, 1964, + 0, 0, 0, 0, -1791, 0, 2145, 0, 850, 0, + 850, 0, 1537, 0, 0, 0, 0, 0, 0, 0, + 850, 2161, 0, -1791, 1016, -1791, -1791, 0, 0, 0, + 0, 1017, 536, 1411, 0, 0, 1414, 1414, 1539, 0, + 0, 1536, 0, 1534, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1540, 0, 0, -1308, 850, 0, + 552, 0, -1791, 0, 0, -1791, -1791, -1791, 0, 0, + 0, 1018, 0, 0, 0, 1745, 552, 0, 0, 0, + 0, 553, 553, 0, 0, 0, 552, 2227, 552, 2231, + 1019, 552, 0, 0, 0, 537, 0, 552, 0, 552, + 0, 1541, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 951, 552, 0, 0, 0, 951, 552, 0, 0, + 0, 552, 552, 552, 552, 1045, 552, 552, 1901, 0, + 0, 0, 1902, 1903, 0, 0, 1904, 1905, 1906, 0, + 0, 0, 1540, 2289, 0, 0, 0, 2670, 0, 538, + 1414, 1299, 0, 850, 850, 850, 850, 850, 0, 1020, + 0, 0, 0, 0, 1965, 0, 0, 920, 539, 0, + 0, 0, 927, 1536, 2318, 928, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2339, 0, 1541, + 0, 1542, 0, 0, 0, 0, 0, 0, 553, 0, + 1413, 1413, 1413, 1413, 1413, 1413, 0, 0, 1413, 1413, + 1413, 1413, 1413, 1413, 1413, 1413, 1413, 1413, 0, 0, + 0, 0, 0, 0, 0, 540, 0, 0, 0, 1536, + 0, 1196, -207, 0, 0, 0, 0, 1197, 1411, 1411, + 1411, 1411, 1411, 1411, 0, 1209, 1411, 1411, 1411, 1411, + 1411, 1411, 1411, 1411, 1411, 1411, 0, 0, 0, 1539, + 0, 0, 0, 0, 0, 1210, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 541, 552, 542, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 850, 0, + 0, 0, 0, 0, 543, 0, 0, 0, 802, 0, + 544, 0, 0, 545, 802, 1534, 0, 0, 0, 0, + 552, 1211, 0, 0, 0, 552, 0, 0, 0, 0, + 0, 0, 1537, 0, 2450, 2450, 0, 0, 0, 0, + 0, 0, 1536, 0, 0, 0, 0, 0, 1908, 1431, + 0, 0, 1198, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1539, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1464, 1540, 0, 0, 2374, 2375, 2376, 2377, + 2378, 2379, 0, 0, 2383, 2384, 2385, 2386, 2387, 2388, + 2389, 2390, 2391, 2392, 0, 0, 0, 1413, 1413, 2836, + 2837, 0, 0, 552, 0, 0, 0, 2486, 0, 0, + 0, 0, 552, 0, 0, 0, 1212, 0, 1909, 0, + 1541, 0, 0, 0, 0, 0, 0, 2889, 0, 0, + 0, 0, 0, 986, 0, 1411, 1411, 1536, 1593, 0, + 0, 0, 2942, 2943, 2944, 2945, 2946, 2947, 2948, 2949, + 2950, 2951, 2048, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1537, 1213, 1540, 1414, 1414, 0, + 0, 0, 0, 0, 0, 1214, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 802, 0, 1215, 0, 0, + 0, 0, 0, 0, 0, 0, 1539, 552, 0, 0, + 0, 0, 802, 0, 553, 553, 2161, 0, 1199, 0, + 0, 1413, 0, 1541, 1536, 0, 0, 0, 0, 1216, + 1537, 0, 0, 1045, 0, 0, 1901, 1190, 0, 0, + 1902, 1903, 0, 0, 1904, 1905, 1906, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 552, 0, 0, 1411, + 0, 0, 552, 0, 0, 0, 0, 0, 0, 1287, + 0, 0, 0, 2495, 2496, 1217, 0, 0, 1809, 1201, + 0, 1218, 0, 0, 0, 1303, 1305, 1308, 1310, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 11, 0, 0, 0, 0, 1219, 0, 0, 0, + 1540, 1220, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1221, 0, 0, 0, 14, + 15, 1536, 0, 1537, 0, 0, 0, 1406, 1910, 1911, + 1912, 0, 1913, 1914, 1915, 1916, 1917, 1918, 0, 1809, + 1539, 0, 0, 0, 0, 0, 850, 1541, 0, 0, + 0, 0, 1539, 0, 0, 1536, 0, 1299, 1414, 0, + 1809, 850, 850, 850, 23, 0, 0, 0, 0, 0, + 0, 0, 1203, 0, 552, 0, 850, 553, 553, 850, + 553, 0, 1539, 1414, 850, 0, 0, 0, 3117, 1539, + 951, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1809, 1809, + 0, 1809, 0, 1907, 0, 0, 0, 0, 1537, 0, + 0, 0, 0, 0, 0, 0, 0, 1539, 0, 0, + 0, 1539, 0, 0, 1536, 0, 1908, 1539, 0, 0, + 516, 0, 0, 0, 1540, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1540, 0, 0, 1539, + 2711, 0, 0, 0, 0, 0, 0, 0, 850, 850, + 850, 0, 0, 0, 0, 0, 0, 1536, 552, 0, + 1411, 553, 552, 0, 0, 0, 1540, 0, 552, 0, + 0, 1541, 0, 1540, 0, 1537, 0, 0, 0, 0, + 0, 0, 0, 1541, 0, 0, 1909, 27, 28, 29, + 0, 0, 1976, 0, 1980, 0, 0, 1414, 1413, 1413, + 0, 2048, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1540, 0, 1541, 0, 1540, 0, 1737, 0, 0, + 1541, 1540, 0, 0, 0, 0, 0, 0, 0, 0, + 1764, 0, 0, 0, 0, 0, 1411, 1411, 0, 0, + 0, 0, 0, 1540, 0, 0, 0, 0, 0, 0, + 0, 1789, 34, 0, 0, 0, 0, 0, 1541, 1536, + 0, 0, 1541, 36, 0, 2810, 0, 0, 1541, 0, + 0, 2161, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1537, 0, 0, 38, 0, 850, 0, 39, + 1541, 552, 0, 0, 0, 552, 552, 552, 0, 0, + 0, 1809, 1745, 1809, 0, 1847, 0, 0, 0, 40, + 0, 0, 0, 0, 1814, 0, 1537, 0, 0, 0, + 0, 0, 41, 1833, 552, 0, 2890, 0, 0, 0, + 0, 0, 0, 44, 0, 3262, 0, 1414, 0, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 45, + 0, 0, 0, 0, 0, 0, 3269, 3270, 0, 0, + 0, 0, 0, 1045, 2786, 2787, 1901, 0, 0, 0, + 1902, 1903, 2318, 46, 1904, 1905, 1906, 0, 850, 0, + 0, 0, 3284, 0, 0, 0, 0, 47, 0, 1413, + 1745, 3060, 0, 0, 0, 1537, 1910, 1911, 1912, 0, + 1913, 1914, 1915, 1916, 1917, 1918, 1847, 0, 0, 0, + 0, 1107, 1107, 0, 3029, 0, 1809, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1411, 0, 0, + 0, 0, 0, 552, 0, 0, 0, 0, 1537, 0, + 850, 850, 850, 850, 0, 0, 0, 0, 0, 1539, + 0, 0, 1411, 553, 0, 1411, 0, 0, 3053, 552, + 951, 0, 1956, 0, 1610, 0, 0, 1611, 3044, 553, + 0, 1612, 1613, 0, 0, 1616, 1617, 1618, 1236, 553, + 0, 553, 1278, 1285, 553, 0, 0, 0, 0, 0, + 553, 0, 553, 0, 0, 3051, 0, 0, 0, 0, + 0, 0, 1621, 0, 0, 553, 0, 0, 0, 1622, + 553, 0, 0, 0, 553, 553, 553, 553, 0, 553, + 553, 1536, 0, 0, 0, 3074, 0, 802, 0, 0, + 0, 0, 0, 0, 0, 1335, 1623, 0, 0, 0, + 1537, 3086, 0, 0, 0, 2161, 0, 1414, 1413, 0, + 0, 2048, 0, 1540, 1360, 2999, 0, 0, 0, 0, + 1405, 0, 0, 1407, 0, 1745, 1418, 1421, 1426, 1429, + 0, 1809, 0, 0, 0, 0, 1908, 0, 0, 0, + 0, 1539, 0, 0, 951, 552, 1411, 0, 0, 0, + 0, 0, 850, 0, 0, 0, 0, 0, 0, 0, + 1541, 0, 0, 1045, 0, 0, 1901, 1471, 1278, 3137, + 1902, 1903, 0, 3452, 1904, 1905, 1906, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1555, 0, + 0, 0, 1624, 0, 0, 0, 0, 1539, 0, 0, + 0, 0, 0, 0, 0, 0, 1909, 1571, 0, 1625, + 0, 0, 0, 0, 1626, 0, 0, 0, 1581, 1582, + 1583, 0, 1587, 1591, 0, 0, 0, 0, 0, 553, + 0, 0, 0, 0, 0, 0, 0, 1627, 1628, 0, + 0, 0, 0, 0, 0, 1540, 0, 3154, 1413, 0, + 0, 1809, 1629, 0, 2146, 1653, 2148, 0, 0, 0, + 0, 0, 0, 2437, 0, 2318, 2158, 0, 1980, 0, + 0, 0, 1471, 1471, 3118, 0, 0, 0, 0, 3188, + 0, 0, 0, 0, 0, 0, 1411, 0, 0, 0, + 1630, 0, 1541, 1631, 0, 0, 0, 0, 0, 0, + 1539, 1540, 0, 0, 2195, 0, 1691, 1632, 0, 0, + 1707, 1712, 3205, 0, 0, 0, 0, 0, 552, 0, + 0, 1107, 1107, 0, 0, 552, 1610, 0, 0, 1611, + 0, 0, 0, 1612, 1613, 1614, 1615, 1616, 1617, 1618, + 0, 0, 0, 0, 0, 0, 553, 0, 1541, 0, + 0, 0, 0, 2206, 1619, 1593, 0, 0, 0, 3233, + 0, 0, 1537, 0, 1621, 0, 0, 0, 0, 0, + 0, 1622, 1045, 0, 0, 1901, 1908, 0, 1278, 1902, + 1903, 552, 0, 1904, 1905, 1906, 552, 1278, 0, 0, + 0, 0, 0, 0, 0, 1539, 0, 0, 1623, 2301, + 2302, 2304, 2305, 2306, 1540, 0, 0, 1634, 0, 0, + 0, 1278, 552, 0, 3192, 0, 1910, 1911, 1912, 0, + 1913, 1914, 1915, 1916, 1917, 1918, 0, 0, 0, 0, + 0, 0, 0, 552, 552, 0, 0, 0, 0, 0, + 553, 0, 0, 0, 0, 0, 1909, 0, 0, 0, + 0, 1541, 850, 1045, 1745, 0, 1901, 0, 3323, 552, + 1902, 1903, 0, 0, 1904, 1905, 1906, 0, 0, 0, + 0, 0, 1539, 850, 0, 0, 3306, 0, 0, 0, + 0, 3061, 0, 0, 0, 0, 0, 0, 0, 553, + 0, 0, 0, 0, 1624, 2568, 1411, 0, 1891, 1540, + 552, 1001, 0, 1001, 0, 0, 0, 0, 0, 0, + 0, 1625, 0, 0, 1635, 0, 1626, 1636, 1637, 1638, + 0, 1639, 1640, 1641, 1642, 1643, 1644, 0, 3086, 0, + 0, 0, 0, 0, 2421, 850, 0, 0, 0, 1627, + 1628, 0, 0, 0, 0, 0, 1541, 0, 0, 0, + 0, 0, 0, 0, 1629, 0, 0, 0, 1426, 0, + 1426, 1426, 0, 0, 0, 0, 850, 0, 0, 0, + 0, 0, 0, 1107, 1107, 0, 1540, 0, 0, 1539, + 0, 0, 0, 0, 0, -2044, 0, 0, 0, 0, + 1107, 0, 1630, 0, 0, 1631, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3205, 0, 0, 0, 1632, + 0, 0, 1633, 1539, 0, 0, 0, 553, 0, 0, + 0, 0, 0, 1541, 0, 0, 0, 3306, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1806, 0, 0, 0, 0, - 0, 850, 0, 0, 0, 0, 0, 0, 0, 0, - 2782, 0, 1538, 1806, 850, 850, 850, 0, 1629, 0, - 0, 0, 0, 0, 0, 0, 0, 552, 1539, 850, - 0, 0, 850, 0, 0, 0, 1308, 0, 0, 1536, - 850, -2041, 0, 0, 0, 0, 951, 0, 0, 0, - 0, 0, 1587, 0, 0, 0, 553, 553, -2041, 553, - 0, 0, 0, -2041, 1806, 1806, 0, 1806, 1540, 1535, - 2090, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2510, 0, 0, 1538, - 0, 0, 0, 0, 0, 1045, 516, 804, 1898, 0, - 0, -2041, 1899, 1900, 0, 1539, 1901, 1902, 1903, 0, - 0, 0, 0, 0, 804, 0, 2704, 0, -2041, 0, - 0, 0, 0, 0, 850, 850, 850, 0, 0, 0, - 0, 0, 0, 552, 0, 1410, 552, 0, 0, 0, - 0, 0, 552, 0, 0, 0, 1536, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1629, 0, 0, 0, - 553, 0, 0, 1540, 0, 1907, 1908, 1909, 0, 1910, - 1911, 1912, 1913, 1914, 1915, 2043, 0, 0, 0, 0, - 1536, 0, 0, 0, 0, 0, 0, 0, 0, 1971, - 0, 1975, 0, 0, 0, 0, 1538, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1410, 1410, 1539, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, -2041, 0, 0, 0, 0, - 1538, 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, 2803, - 1540, 0, 0, 0, 0, 2156, 1539, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -2041, 0, 0, 1536, - 0, 850, 0, 0, 0, 552, 0, 864, 0, 552, - 552, 552, 0, 0, 0, 1806, 1742, 1806, 0, 1844, - 0, 0, 0, -1773, 0, 0, 0, 0, 0, 0, - 1412, 0, 0, 0, 0, 0, 0, 0, 552, 0, - 2883, 0, 0, 1536, 0, 0, 0, 0, 1905, 1538, - 0, 0, 0, 552, 552, 552, 552, 552, 552, 552, - 552, 552, 552, 0, 0, 1539, 0, 0, 0, 0, - 0, 0, 0, 0, 1535, 0, 0, 0, 0, 0, - 0, 0, 0, 1045, 0, 2310, 1898, 1540, 0, 0, - 1899, 1900, 850, 1538, 1901, 1902, 1903, 0, 0, 0, - 0, 0, 1742, -2041, 0, 0, 0, 0, 0, 1539, - 1636, 1637, 1638, 1639, 1640, 1641, 0, 0, 1906, 0, - 1844, 1540, 0, -1773, 1413, 0, 0, 0, 0, 0, - 1806, 11, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1410, 0, 0, 0, 1536, 0, 552, 0, 0, - 0, 0, 0, 0, 850, 850, 850, 850, 0, 14, - 15, 0, 0, 0, 0, 0, 1410, 0, 0, 1410, - -1773, 0, 0, 552, 951, 0, 0, 0, 0, 1587, - 0, 0, 3038, 0, -1773, 0, 0, 0, 0, -1773, - 0, 553, 0, 0, -1773, 1538, 0, 0, 0, 0, - 1540, 0, 0, -1773, 23, 0, 553, 0, -1773, 3045, - 0, 1539, 1587, 0, 0, 0, 553, 1711, 553, 0, - 0, 553, 0, 0, 0, 0, 1412, 553, 0, 553, - 0, 85, 0, 0, 0, 0, 0, 85, 0, 3068, - -1773, 802, 553, 0, 1540, 0, 0, 553, 0, 0, - 0, 553, 553, 553, 553, 3080, 553, 553, 0, 2156, - -1773, 0, 0, 2825, 0, 2043, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1742, - 0, 0, 0, 0, 0, 1806, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -2041, 0, 951, 552, - 1410, 0, 0, 0, 0, 0, 850, 0, 0, -1773, - 0, 0, -1773, 0, 0, 0, 0, 0, -1773, 0, - 1413, 0, 0, 3131, 0, 0, 0, 0, 1907, 1908, - 1909, 0, 1910, 1911, 1912, 1913, 1914, 1915, 0, 0, - 0, 0, 85, 0, 0, 0, 1540, 27, 28, 29, - 0, 0, 0, 0, 0, 0, 0, 0, -1773, 0, - 0, 0, 0, 0, 0, 0, 1906, 0, 0, 85, - 0, 0, 85, 0, 0, 0, 0, 0, 0, 0, - 0, -1773, 0, 0, 0, 0, 0, 0, 0, 1607, - 0, 0, 1608, 0, 0, 0, 1609, 1610, 0, 0, - 0, 3148, 0, 0, 1806, 0, 553, 0, 0, 0, - 1536, 0, 34, 0, 0, 0, 0, 2310, 0, 0, - 0, 0, 1587, 36, 0, 0, 0, 1618, 0, 0, - 0, 0, 0, 3182, -2041, 0, 0, 0, 2430, 852, - 1410, 0, 0, 1975, 0, 38, 0, 0, 0, 39, - 1412, 1412, 0, 0, 0, 0, 1412, 0, 0, -1788, - 1538, 1620, 0, 0, 0, 0, 3199, -1773, 0, 40, - 0, 0, 552, 0, 0, 0, 1539, -1773, 0, 0, - 552, 0, 41, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 44, 0, 0, -1773, 804, -1773, -1773, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, - 0, 864, 0, 0, 3228, 0, 0, 0, 0, 0, - 0, 553, 0, 0, 0, 0, 3058, 0, 0, 0, - 1592, 0, 0, 46, 0, -1773, 552, 0, -1773, -1773, - -1773, 552, 0, 0, 1413, 1413, 0, 47, 0, 0, - 1413, 0, 0, 0, 0, 0, 0, -2041, 0, -1788, - 0, 0, 0, 0, 0, 0, 0, 552, 0, 0, - 0, 1107, 1107, 0, -2041, 0, 1907, 1908, 1909, -2041, - 1910, 1911, 1912, 1913, 1914, 1915, 0, 0, 552, 552, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -1788, 850, 0, 1742, - 0, 1540, 0, 552, 0, 553, 0, -2041, 0, 0, - -1788, 0, 0, 0, 0, -1788, 0, 0, 850, 0, - -1788, 3301, 0, 0, 0, 0, 0, 0, 1235, -1788, - 0, 0, 1279, 1284, -1788, 0, 0, 0, 0, 0, - 0, 1410, 0, 0, 0, 552, 1001, 0, 0, 1001, - 0, 0, 0, 0, 553, 0, 0, 0, 0, 0, - 2561, 0, 1629, 0, 85, 0, -1788, 0, 0, 0, - 0, 0, 0, 0, 3080, 0, 0, 0, 0, 0, - 0, 850, 0, 0, 0, 1334, -1788, 0, 0, 0, + 0, 0, 0, 0, 1745, 1909, 1910, 1911, 1912, 0, + 1913, 1914, 1915, 1916, 1917, 1918, 1908, 951, 951, 0, + 3306, 951, 0, 0, 0, 0, 0, 0, 0, 1944, + 0, 0, 0, 1540, 0, 0, 0, 0, 0, 0, + 552, 0, 1539, 0, 0, 2023, 0, 0, 0, 0, + 0, 0, 0, 2026, 0, 0, 0, 0, 0, 1634, + 0, 0, 1745, 0, 0, 0, 0, 1540, 0, 3306, + 0, 553, 0, 0, 0, 553, 0, 0, 0, 0, + 1541, 1976, 0, 0, 0, 1539, 1909, 0, 0, 0, + 0, 0, 2072, 0, 0, 0, 0, 0, 2076, 2077, + 2078, 2079, 2080, 2081, 2082, 2083, 951, 0, 0, 0, + 2092, 2093, 0, 0, 1541, 2104, 0, 0, 0, 2107, + 0, 2161, 2115, 2116, 2117, 2118, 2119, 2120, 2121, 2122, + 2123, 0, 0, 2124, 0, 0, 0, 0, 0, 0, + 1107, 1610, 1278, 0, 1611, 0, 1540, 0, 1612, 1613, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1587, 0, 1359, 0, 0, 0, 0, 0, - 1404, 0, 850, 1406, 0, 0, 1417, 1420, 1425, 1428, - 0, 0, 0, 0, 0, 0, 0, 2175, 0, 0, - 0, 0, 0, 0, 0, -1788, 0, 0, -1788, 0, - 0, 0, 0, 0, -1788, 0, 0, 0, 0, 0, - 0, 3199, 0, 0, 0, 0, 0, 1468, 1279, 0, - 0, 0, -2041, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3301, 2132, 0, 0, 1552, 553, - 0, 0, 0, 0, -1788, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1568, 0, 0, - 0, 1742, 0, 0, 0, 0, 0, -1788, 1578, 1579, - 1580, 0, 1584, 1588, 951, 951, 0, 3301, 951, 0, - 0, 1413, 0, 0, 0, 0, 1941, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 552, 0, - 0, 0, 0, 0, 1650, 0, 0, 0, 0, 85, - 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1742, 1468, 1468, 0, 0, 852, 0, 3301, 0, -2041, - 0, 0, 0, 0, 0, 0, 1636, 1637, 1638, 1639, - 1640, 1641, 0, 0, 0, 553, 0, 0, 553, 0, - 0, 0, 0, -1788, 1971, 0, 1689, 0, 0, 0, - 1705, 1710, 0, -1788, 0, 951, 0, 0, 0, 0, - 0, 1107, 1107, 0, 0, 0, 0, 0, 0, 0, - 2156, 0, -1788, 0, -1788, -1788, 0, 85, 0, 85, - 0, 1412, 1412, 1412, 1412, 1412, 1412, 0, 0, 1412, - 1412, 1412, 1412, 1412, 1412, 1412, 1412, 1412, 1412, 0, + 0, 2150, 0, 0, 0, 0, 1635, 0, 0, 1636, + 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, 1621, + 0, 0, 0, 0, 0, 0, -2044, 1539, 0, 1540, + 0, 0, 2472, 1541, 1582, 1583, 0, 0, 0, 0, + 0, 0, 0, 0, 553, 0, 0, 0, 553, 553, + 553, 0, 0, 1623, 0, 1910, 1911, 1912, 0, 1913, + 1914, 1915, 1916, 1917, 1918, 0, 0, 0, 0, 0, + 0, 0, 2644, 0, 0, 0, 1541, 553, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2659, 2660, 2662, + 0, 0, 553, 553, 553, 553, 553, 553, 553, 553, + 553, 553, 2673, 0, 0, 2676, 0, 0, 0, 0, + 2681, 0, 0, 0, 0, 0, 0, 0, 2789, 0, + 0, 0, 2272, 0, 0, 0, 1278, 0, 0, 2282, + 2283, 1540, 0, 0, 0, 0, 1910, 1911, 1912, 0, + 1913, 1914, 1915, 1916, 1917, 1918, 0, 0, 0, -2044, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, -1788, 0, 0, -1788, -1788, -1788, 1279, 0, 85, - 0, 0, 0, 0, 0, 0, 1279, 0, 0, 0, - 0, 0, 0, 0, 0, 85, 0, 0, 0, 85, + 0, 0, 0, 0, 0, 0, -2044, 0, 0, 0, + 1278, -2044, 0, 0, 0, 0, 0, 0, 1541, 0, + 0, 0, 0, 0, 0, 0, 1976, 0, 0, 1335, + 2347, 0, 0, 0, 2718, 2719, 2720, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -2044, + 0, 0, 2437, 0, 0, 0, 0, 0, 0, 2369, + 2370, 0, 2371, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1279, 0, 1363, 1364, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 553, 0, 0, - 0, 553, 553, 553, 0, 1413, 1413, 1413, 1413, 1413, - 1413, 0, 0, 1413, 1413, 1413, 1413, 1413, 1413, 1413, - 1413, 1413, 1413, 1365, 1366, 0, 0, 1367, 1368, 0, - 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 553, 553, 553, 553, 553, - 553, 553, 553, 553, 553, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1888, 0, 0, - 0, 0, 0, 0, 0, 0, 717, 0, 0, 0, + 1610, 0, 0, 1611, 0, -45, 0, 1612, 1613, 0, + 0, 2397, 2398, 0, 0, 2150, 0, 0, 0, 0, + 0, 0, 0, 0, 1632, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2, 1621, 3, + 4, 0, 0, 0, 2425, -2044, 0, 0, 0, 1539, + 2431, 0, 5, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 7, 0, 1471, 0, + 1278, 0, 1623, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, 0, 9, + 0, 10, 0, 2828, 0, 0, 0, 0, 553, 0, + 0, 0, 0, 11, 0, 12, 2465, 0, 0, 0, + 0, 0, 1196, 0, 0, 0, 13, 0, 1197, 0, + 0, 0, 0, 0, -2044, 1008, 1209, 0, 0, 0, + 1009, 14, 15, 16, 0, 0, 0, 3064, 0, 0, + 0, 0, 17, 0, 0, 2484, 1210, 0, 18, 0, + 2487, 2488, 0, 1540, 0, 0, 19, 0, 20, 21, + 0, 0, 0, 0, 0, 0, 0, 0, -2044, 0, + 0, 0, 22, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 2972, -2044, 0, 0, 0, 1010, + -2044, 0, 1211, 0, 2509, 0, 0, 2512, 0, 2514, + 1541, 0, 24, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2518, 0, 0, 25, 0, + 0, 0, 0, 1198, 0, 0, 0, 0, -2044, 0, + 0, -2044, 0, 0, 0, 0, 0, 0, 1639, 1640, + 1641, 1642, 1643, 1644, 26, 0, 3008, 3009, 3010, 3011, + 0, 0, 0, 0, 0, 1691, 0, 0, 0, 0, + 1011, 0, 0, 0, 0, 0, 0, 0, 1183, 0, + 0, 3213, 1712, 2122, 0, 0, 0, 0, 2437, 0, + 0, 0, 0, 1632, 0, 0, 0, 1212, 0, 0, + 0, 1107, 0, 0, 0, 1610, 1012, 0, 1611, 0, + 2572, 0, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, + 0, 0, 1013, 0, 0, 0, 0, 0, 0, 27, + 28, 29, 1014, 1619, 0, 0, 0, 30, 1415, 0, + 31, 0, 0, 1621, 553, 0, 1213, 0, 0, 553, + 1622, 0, 0, 0, 0, 0, 1214, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1015, 1583, 1215, 32, + 0, 0, 0, 1278, 0, 553, 0, 1623, 33, 0, + 0, 0, 0, 0, 0, 0, 0, 1184, 0, 1199, + 0, 0, 0, -2044, 34, 0, 553, 553, 0, 0, + 1216, 35, 0, 0, 0, 36, 0, 0, 3124, 0, + 0, 0, 1016, 0, 0, 37, 0, 0, 0, 1017, + 0, 0, 553, 1008, 0, 0, 0, 38, 1009, 0, + 0, 39, 2679, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2247, 0, 0, 0, + 1201, 40, 1218, 0, 0, 0, 0, 1647, 0, 1018, + 0, 0, 0, 553, 41, 0, 0, 42, 0, 0, + 43, 0, 0, 1624, 0, 44, 0, 1219, 1019, 0, + 0, 0, 2248, 0, 0, 0, 0, 1010, 0, 0, + 1625, 45, 0, 0, 0, 1626, 1221, 0, 0, 0, + -2044, 1647, 0, 0, 0, 0, 0, 1639, 1640, 1641, + 1642, 1643, 1644, 0, 0, 46, 0, 0, 1627, 1628, + 0, 0, 0, 1609, 0, 0, 0, 0, 1610, 47, + 0, 1611, -45, 1629, 1415, 1612, 1613, 1614, 1615, 1616, + 1617, 1618, 0, 0, 0, 0, 0, 1020, 0, 0, + 0, 0, 1185, 1203, 0, 0, 1619, 0, 1011, 0, + 1620, 0, 2757, 0, 0, 0, 1621, 0, 2759, 2026, + 0, 1630, 0, 1622, 1631, 0, 0, 0, 0, 2765, + 0, 0, 0, 0, 0, 0, 1647, 0, 1632, 0, + 2774, 1633, 0, 2777, 1012, 2779, 0, 0, 0, 0, + 1623, 0, 0, 2783, 0, 0, 0, 0, 0, 0, + 1013, 2790, 2791, 0, 0, 0, 0, 0, 2798, 0, + 1014, 0, 0, 0, 0, 0, 0, 0, 1647, 0, + 0, 0, 0, 2807, 0, 1647, 0, 0, 0, 0, + 0, 0, 0, 2822, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 553, 1015, 0, 0, 0, 0, 0, + 0, 0, 0, 1107, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1186, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1647, 0, 0, 1634, 0, + 0, 0, 0, 0, 0, 0, 1624, 0, 0, 0, + 1016, 0, 0, 0, 0, 0, 0, 1017, 3279, 0, + 1647, 0, 0, 1625, 0, 0, 0, 0, 1626, 0, + 2272, 0, 2272, 0, 0, 0, 0, 0, 0, 3304, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 85, 1412, 1412, 0, 0, - 0, 0, 1369, 1370, 0, 0, 0, 0, 0, 0, + 0, 1627, 1628, 0, 0, 0, 0, 1018, 0, 0, + 0, 0, 0, 0, 0, 1647, 1629, 1647, 0, 1415, + 1415, 0, 1919, 0, 0, 1415, 1019, 0, 1647, 0, + 0, 1647, 0, 0, 0, 0, 1647, 0, 0, 1647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 85, 0, 0, 0, 0, 1425, 0, 1425, - 1425, 0, 0, 718, 0, 0, 0, 0, 0, 1971, - 0, 0, 1107, 1107, 0, 0, 0, 0, 0, 719, - 0, 0, 0, 0, 0, 0, 0, 0, 1107, 0, - 0, 0, 0, 0, 0, 2430, 1371, 1372, 1373, 1374, - 1375, 1376, 1377, 1378, 0, 0, 1379, 1380, 0, 0, + 0, 3343, 0, 0, 1630, 1635, 0, 1631, 1636, 1637, + 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, 0, 0, + 0, 1632, 0, 0, 1633, 1894, 0, 3024, 3025, 0, + 0, 1647, 3369, 0, 0, 0, 0, 0, 0, 717, + 0, 0, 0, 0, 0, 1020, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1413, 1413, 0, 0, 0, 0, 0, 0, 720, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, - 1412, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 722, 0, 0, 0, 0, 723, 0, 0, 0, 0, + 0, 0, 3048, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3052, 0, 0, 0, + 0, 3054, 3055, 0, 0, 0, 3056, 0, 0, 0, + 0, 3059, 0, 0, 3062, 3063, 718, 0, 0, 2272, + 1278, 0, 0, 3071, 0, 0, 0, 0, 0, 0, + 0, 0, 719, 0, 1107, 1647, 0, 0, 0, 0, + 0, 1634, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1647, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1647, 1647, 1647, 0, 0, 0, 1647, 0, 0, + 0, 1647, 0, 0, 0, 1363, 0, 815, 3112, 0, + 0, 720, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 722, 0, 3131, 0, 0, 723, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 724, 0, 0, 0, 0, 0, - 0, 0, 2018, 0, 0, 0, 0, 0, 0, 0, - 2021, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1381, - 1382, 553, 0, 0, 0, 0, 0, 725, 0, 0, - 0, 726, 0, 0, 1413, 0, 0, 0, 0, 2067, - 0, 0, 0, 0, 0, 2071, 2072, 2073, 2074, 2075, - 2076, 2077, 2078, 0, 0, 0, 0, 2087, 2088, 0, - 0, 0, 2099, 0, 0, 0, 2102, 0, 0, 2110, - 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 0, 0, - 2119, 0, 0, 0, 0, 1607, 0, 1107, 1608, 1279, - 0, 0, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 0, - 0, 727, 0, 0, 0, 0, 0, 0, 2145, 0, - 0, 0, 0, 1616, 1383, 1384, 728, 0, 0, 0, - 0, 0, 0, 1618, 0, 0, 0, 0, 0, 0, - 1619, 0, 0, 0, 0, 0, 0, 0, 1385, 1386, - 0, 0, 1579, 1580, 0, 0, 0, 0, 0, 729, - 0, 0, 730, 0, 0, 0, 0, 1620, 1988, 0, - 0, 0, 1607, 731, 0, 1608, 732, 0, 0, 1609, - 1610, 1611, 1612, 1613, 1614, 1615, 0, 0, 0, 0, - 0, 0, 0, 0, 733, 0, 0, 0, 0, 0, - 1616, 0, 0, 0, 3207, 0, 0, 0, 734, 0, - 1618, 0, 2430, 1414, 0, 736, 0, 1619, 0, 0, - 0, 0, 0, 0, 0, 737, 0, 0, 0, 0, - 0, 738, 0, 0, 0, 0, 0, 0, 0, 2267, - 0, 0, 0, 1279, 1620, 0, 2277, 2278, 0, 0, - 0, 0, 0, 0, 0, 1412, 1412, 0, 739, 0, - 0, 0, 0, 1621, 0, 0, 0, 0, 553, 0, - 0, 0, 0, 553, 0, 0, 0, 0, 0, 0, - 1622, 0, 0, 0, 1279, 1623, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 553, - 0, 0, 0, 0, 0, 0, 1334, 2342, 1624, 1625, + 0, 0, 0, 1647, 0, 0, 0, 724, 0, 0, + 1364, 1365, 0, 0, 0, 0, 0, 0, 1635, 0, + 0, 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, + 1644, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1647, 0, 0, 0, 0, 0, 0, 0, 0, + 725, 1366, 1367, 0, 726, 1368, 1369, 1647, 0, 0, + 0, 1610, 1647, 0, 1611, 3165, 0, 0, 1612, 1613, + 1614, 1615, 1616, 1617, 1618, 0, 0, 0, 0, 1919, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1619, + 0, 0, 0, 2769, 0, 0, 0, 0, 0, 1621, + 0, 0, 0, 0, 0, 0, 1622, 0, 1610, 0, + 0, 1611, 1591, 0, 0, 1612, 1613, 1614, 1615, 1616, + 1617, 1618, 0, 0, 727, 0, 0, 0, 0, 0, + 1370, 1371, 0, 1623, 0, 0, 1619, 0, 0, 728, + 0, 0, 0, 0, 0, 2484, 1621, 0, 0, 0, + 0, 0, 0, 1622, 0, 0, 3225, 3226, 0, 0, + 3227, 0, 1583, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 729, 0, 0, 730, 0, 0, 0, 0, + 1623, 0, 0, 0, 0, 0, 731, 3245, 0, 732, + 0, 0, 0, 0, 1372, 1373, 1374, 1375, 1376, 1377, + 1378, 1379, 0, 0, 1380, 1381, 0, 733, 0, 0, + 0, 3257, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 734, 0, 0, 0, 0, 0, 0, 736, 1624, + 0, 0, 0, 0, 0, 0, 0, 0, 737, 0, + 0, 1647, 0, 0, 738, 0, 1625, 0, 0, 1919, + 1919, 1626, 1415, 1415, 1415, 1415, 1415, 1415, 0, 0, + 1415, 1415, 1415, 1415, 1415, 1415, 1415, 1415, 1415, 1415, + 1919, 739, 0, 0, 1627, 1628, 1624, 0, 0, 0, + 0, 0, 3303, 0, 0, 0, 0, 0, 0, 1629, + 0, 0, 0, 1625, 0, 0, 0, 0, 1626, 0, + 3024, 0, 0, 0, 3320, 0, 0, 0, 1107, 0, + 0, 0, 0, 0, 0, 0, 0, 1382, 1383, 3329, + 0, 1627, 1628, 0, 2272, 0, 2272, 1630, 0, 0, + 1631, 0, 0, 0, 1107, 0, 1629, 0, 0, 0, + 0, 0, 0, 0, 1632, 0, 0, 1633, 0, 0, + 0, 0, 3354, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 553, 553, 0, 1626, 0, 0, 0, 0, 0, 0, - 0, 0, 1644, 0, 0, 0, 2364, 2365, 0, 2366, - 1621, 0, 0, 0, 0, 553, 0, 0, 0, 1413, - 1413, 0, 0, 0, 0, 0, 0, 1622, 0, 0, - 0, 1627, 1623, 0, 1628, 0, 0, 0, 2392, 2393, - -45, 0, 2145, 0, 0, 1644, 0, 0, 1629, 0, - 0, 1630, 0, 0, 0, 1624, 1625, 553, 0, 0, - 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, - 1626, 2420, 2, 0, 3, 4, 2425, 0, 0, 1414, - 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, - 0, 0, 6, 1468, 0, 1279, 0, 0, 0, 0, - 0, 7, 0, 0, 0, 0, 0, 0, 1627, 0, - 0, 1628, 0, 0, 0, 8, 1412, 0, 0, 0, - 0, 0, 0, 0, 9, 1629, 10, 0, 1630, 0, - 1644, 2458, 0, 0, 0, 0, 0, 0, 11, 0, - 12, 3022, 0, 0, 0, 0, 0, 0, 1631, 0, - 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 14, 15, 16, 0, - 2477, 0, 0, 0, 1644, 2480, 2481, 17, 0, 1644, - 0, 0, 0, 18, 0, 3047, 0, 0, 0, 0, - 0, 19, 0, 20, 21, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, - 1413, 23, 0, 0, 0, 0, 0, 0, 0, 2502, - 0, 0, 2505, 0, 2507, 1631, 0, 0, 0, 1644, - 0, 0, 0, 0, 0, 1413, 0, 24, 0, 0, - 2511, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 553, 0, 0, 25, 1644, 1632, 0, 0, 1633, 1634, - 1635, 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, 0, - 0, 0, 0, 0, 0, 1412, 0, 0, 0, 26, - 1689, 2465, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1710, 2117, 1644, - 0, 1644, 0, 1414, 1414, 0, 1916, 0, 0, 1414, - 0, 0, 1644, 0, 0, 1644, 1107, 0, 0, 0, - 1644, 0, 0, 1644, 0, 2565, 0, 0, 0, 0, - 0, 0, 1632, 0, 0, 1633, 1634, 1635, 0, 1636, - 1637, 1638, 1639, 1640, 1641, 0, 0, 0, 0, 0, - 0, 0, 1891, 0, 27, 28, 29, 0, 0, 0, - 0, 0, 30, 1644, 0, 31, 0, 0, 0, 1413, + 0, 0, 0, 1647, 1630, 0, 1647, 1631, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1580, 0, 0, 0, 0, 0, 1279, 0, - 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, - 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1412, 0, 0, 0, 34, - 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, - 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 37, 0, 0, 0, 2670, 0, 0, 1644, 0, 0, - 0, 0, 38, 0, 0, 0, 39, 0, 0, 0, - 0, 0, 0, 1644, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1644, 1644, 1644, 40, 0, 0, 1644, - 0, 0, 0, 1644, 0, 0, 0, 0, 0, 41, - 0, 0, 42, 0, 0, 43, 0, 0, 0, 0, - 44, 0, 0, 0, 0, 0, 0, 0, 0, 1413, - 0, 0, 0, 0, 0, 0, 45, 0, 0, 1363, - 1364, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1632, 0, 0, 1633, 0, 0, 0, 0, 0, + 0, 3380, 0, 0, 0, 0, 0, 1610, 0, 0, + 1611, 3024, 1384, 1385, 1612, 1613, 1614, 1615, 1616, 1617, + 1618, 0, 1647, 1107, 0, 0, 1647, 1647, 1647, 1647, + 1647, 1647, 1647, 1647, 0, 1619, 1386, 1387, 0, 1415, + 1415, 0, 1647, 1647, 1634, 1621, 0, 0, 0, 0, + 0, 0, 1622, 0, 1647, 3423, 0, 1647, 0, 0, + 0, 0, 0, 0, 0, 1647, 1647, 1647, 1647, 1647, + 1647, 1647, 1647, 1647, 1647, 0, 0, 0, 0, 1623, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 46, 0, 0, 0, 0, 1644, 0, 0, 0, 0, - 0, 0, 0, 0, 47, 0, 0, -45, 0, 0, - 1365, 1366, 0, 0, 1367, 1368, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2750, 0, 0, 0, 0, - 0, 2752, 2021, 0, 1644, 0, 0, 0, 0, 0, - 0, 0, 2758, 0, 0, 0, 0, 0, 0, 0, - 1644, 0, 0, 2767, 0, 1644, 2770, 0, 2772, 0, - 0, 0, 0, 0, 0, 0, 2776, 0, 0, 0, - 0, 0, 1916, 0, 2783, 2784, 3318, 0, 0, 0, - 0, 2791, 0, 0, 0, 0, 0, 0, 0, 1369, - 1370, 0, 0, 0, 0, 0, 2800, 0, 0, 1606, - 0, 0, 0, 0, 1607, 0, 2815, 1608, 0, 0, - 0, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 0, 0, - 0, 0, 0, 0, 0, 0, 1107, 0, 0, 0, - 0, 0, 1616, 0, 0, 0, 1617, 0, 0, 0, - 0, 0, 1618, 0, 0, 0, 0, 0, 0, 1619, - 0, 0, 0, 1371, 1372, 1373, 1374, 1375, 1376, 1377, - 1378, 0, 0, 1379, 1380, 0, 0, 0, 0, 0, - 1413, 0, 0, 0, 0, 0, 1620, 0, 0, 0, - 0, 0, 0, 2267, 0, 2267, 0, 0, 0, 0, + 0, 1634, 0, 0, 1610, 0, 0, 1611, 0, 0, + 1647, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1619, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1621, 0, 0, 0, 0, 0, 0, 1622, + 0, 0, 0, 3477, 3477, 3477, 0, 0, 0, 0, + 0, 1635, 0, 1415, 1636, 1637, 1638, 0, 1639, 1640, + 1641, 1642, 1643, 1644, 0, 0, 1623, 0, 2063, 0, + 3477, 0, 0, 0, 0, 1624, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1625, 0, 0, 0, 0, 1626, 1635, 0, + 0, 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, + 1644, 3477, 0, 0, 0, 2063, 0, 0, 0, 0, + 1627, 1628, 1647, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1647, 1647, 0, 1629, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1644, 0, 0, 0, 0, 0, 0, - 0, 1916, 1916, 0, 1414, 1414, 1414, 1414, 1414, 1414, - 0, 0, 1414, 1414, 1414, 1414, 1414, 1414, 1414, 1414, - 1414, 1414, 1916, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1621, 0, 0, 0, 1381, 1382, 0, 0, - 3017, 3018, 0, 0, 0, 0, 0, 0, 0, 1622, - 0, 0, 0, 0, 1623, 0, 0, 0, 0, 0, + 0, 0, 1624, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1630, 0, 0, 1631, 0, 0, 1625, + 0, 0, 0, 0, 1626, 0, 0, 0, 0, 0, + 1632, 0, 0, 1633, 0, 0, 0, 1647, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1627, 1628, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1647, + 1647, 1647, 1629, 0, 1919, 1919, 1919, 1919, 1919, 1919, + 0, 0, 0, 1919, 1919, 1919, 1919, 1919, 1919, 1919, + 1919, 1919, 1919, 0, 0, 0, 0, 1647, 1647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 3042, 0, 1624, 1625, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3046, - 0, 0, 1626, 0, 3048, 3049, 0, 0, 0, 3050, - 0, 0, 0, 0, 3053, 0, 0, 3056, 3057, 0, - 0, 0, 2267, 1279, 0, 0, 3065, 0, 0, 0, - 0, 0, 0, 1644, 0, 0, 1644, 1107, 0, 0, - 1627, 1383, 1384, 1628, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1629, 0, 0, - 1630, 0, 0, 0, 0, 1385, 1386, 1607, 0, 0, - 1608, 0, 0, 0, 1609, 1610, 0, 0, 1613, 1614, - 1615, 3106, 1644, 0, 0, 0, 1644, 1644, 1644, 1644, - 1644, 1644, 1644, 1644, 0, 1616, 0, 0, 0, 1414, - 1414, 0, 1644, 1644, 0, 1618, 0, 0, 3125, 0, - 0, 0, 1619, 0, 1644, 0, 0, 1644, 0, 0, - 0, 0, 0, 0, 0, 1644, 1644, 1644, 1644, 1644, - 1644, 1644, 1644, 1644, 1644, 0, 0, 0, 0, 1620, - 1607, 0, 0, 1608, 0, 0, 0, 1609, 1610, 1611, - 1612, 1613, 1614, 1615, 0, 0, 0, 1631, 0, 0, - 1644, 0, 0, 0, 0, 0, 0, 0, 1616, 0, - 0, 0, 2762, 0, 0, 0, 0, 0, 1618, 0, - 0, 0, 0, 0, 0, 1619, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3158, 0, 0, + 1630, 0, 0, 1631, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1647, 0, 1632, 0, 0, + 1633, 1647, 0, 0, 1610, 0, 0, 1611, 0, 0, + 1634, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1620, 1414, 0, 0, 0, 0, 0, 0, + 0, 0, 1619, 0, 0, 1647, 0, 0, 0, 0, + 0, 0, 1621, 0, 0, 0, 0, 0, 0, 1622, + 0, 0, 0, 0, 1647, 0, 0, 1647, 1647, 0, + 0, 0, 0, 0, 0, 1919, 1919, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1623, 0, 0, 1647, + 1415, 1415, 1647, 0, 1647, 0, 0, 0, 1647, 0, + 0, 0, 0, 0, 0, 0, 0, 1634, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1635, 0, 0, + 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, + 0, 0, 0, 0, 2368, 0, 0, 0, 0, 0, + 0, 0, 1647, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1610, 0, 0, 1611, 0, 0, 0, 1612, + 1613, 1614, 1615, 1616, 1617, 1618, 0, 0, 0, 0, + 0, 0, 1624, 0, 0, 0, 0, 0, 0, 0, + 1619, 0, 0, 0, 0, 0, 0, 0, 0, 1625, + 1621, 0, 0, 0, 1626, 0, 0, 1622, 0, 0, + 0, 0, 0, 0, 1635, 0, 0, 1636, 1637, 1638, + 0, 1639, 1640, 1641, 1642, 1643, 1644, 1627, 1628, 0, + 0, 2469, 0, 0, 1623, 0, 0, 1610, 0, 0, + 1611, 0, 1629, 0, 1612, 1613, 1614, 1615, 1616, 1617, + 1618, 0, 0, 0, 0, 0, 0, 0, 0, 1647, + 0, 0, 0, 0, 0, 1619, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1621, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1588, 0, 0, 0, 0, - 0, 0, 1622, 0, 0, 0, 0, 1623, 0, 0, - 0, 0, 0, 0, 1632, 1279, 0, 1633, 1634, 1635, - 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, 0, 2477, - 1624, 1625, 1644, 0, 0, 0, 0, 0, 0, 0, - 3220, 3221, 1644, 1644, 3222, 1626, 1580, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1621, 0, + 1630, 1415, 1622, 1631, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1632, 0, 0, + 1633, 0, 0, 0, 0, 0, 0, 0, 0, 1623, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3240, 0, 0, 0, 1622, 0, 0, 0, 0, - 1623, 0, 0, 1627, 0, 0, 1628, 0, 0, 0, - 0, 0, 0, 0, 0, 3252, 0, 0, 0, 0, - 1629, 0, 0, 1624, 1625, 0, 0, 1644, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1626, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1644, - 1644, 1644, 0, 0, 1916, 1916, 1916, 1916, 1916, 1916, - 0, 0, 0, 1916, 1916, 1916, 1916, 1916, 1916, 1916, - 1916, 1916, 1916, 0, 0, 0, 1627, 1644, 1644, 1628, - 0, 0, 0, 0, 0, 3297, 0, 0, 0, 0, - 0, 0, 0, 1629, 0, 0, 1630, 0, 0, 0, - 0, 0, 0, 0, 3017, 1644, 1607, 0, 3315, 1608, - 1644, 0, 1107, 1609, 1610, 1611, 1612, 1613, 1614, 1615, - 1631, 0, 0, 0, 3325, 0, 0, 0, 0, 2267, - 0, 2267, 0, 0, 1616, 0, 0, 0, 717, 1107, - 0, 0, 0, 1644, 1618, 0, 0, 0, 0, 0, - 0, 1619, 0, 0, 0, 0, 0, 3350, 0, 0, - 0, 0, 1644, 0, 0, 1644, 1644, 0, 0, 0, - 0, 0, 0, 1916, 1916, 0, 0, 0, 1620, 0, - 0, 0, 0, 0, 0, 0, 0, 1644, 1414, 1414, - 1644, 0, 1644, 1631, 0, 718, 1644, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3376, 0, 0, 0, - 0, 719, 0, 0, 0, 0, 3017, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1632, 0, 1107, - 1633, 1634, 1635, 0, 1636, 1637, 1638, 1639, 1640, 1641, + 1610, 0, 0, 1611, 0, 0, 0, 1612, 1613, 0, + 1624, 1616, 1617, 1618, 0, 0, 0, 1647, 0, 1647, + 0, 0, 0, 0, 0, 1647, 0, 1625, 1619, 0, + 0, 0, 1626, 0, 1647, 0, 0, 1647, 1621, 1647, + 0, 0, 0, 1647, 0, 1622, 1919, 1919, 0, 0, + 1647, 1647, 0, 0, 0, 1627, 1628, 0, 1647, 0, + 0, 0, 0, 0, 0, 0, 0, 1647, 0, 0, + 1629, 0, 1623, 0, 0, 0, 0, 1634, 0, 0, + 0, 0, 1647, 0, 0, 1624, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1644, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 720, 3420, 0, 0, 0, 0, 0, 0, 0, 0, - 721, 0, 0, 0, 1621, 0, 0, 0, 0, 0, - 0, 0, 722, 0, 0, 0, 0, 723, 0, 0, - 0, 1622, 0, 0, 0, 0, 1623, 0, 0, 0, - 1632, 0, 0, 1633, 1634, 1635, 0, 1636, 1637, 1638, - 1639, 1640, 1641, 0, 0, 0, 724, 2058, 0, 1624, - 1625, 0, 0, 0, 0, 0, 0, 0, 1607, 0, - 0, 1608, 0, 0, 1626, 1609, 1610, 1611, 1612, 1613, - 1614, 1615, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3475, 3475, 3475, 0, 1644, 1616, 0, 0, 725, - 0, 0, 0, 726, 0, 0, 1618, 0, 0, 0, - 0, 0, 1627, 1619, 0, 1628, 0, 0, 3475, 1414, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1629, - 0, 0, 1630, 0, 0, 0, 0, 0, 0, 0, - 1620, 0, 1607, 0, 0, 1608, 0, 0, 0, 1609, - 1610, 1611, 1612, 1613, 1614, 1615, 0, 0, 0, 3475, - 0, 0, 0, 0, 0, 0, 0, 539, 0, 0, - 1616, 0, 0, 727, 0, 1644, 0, 1644, 0, 0, - 1618, 0, 0, 1644, 0, 0, 0, 1619, 728, 0, - 0, 0, 1644, 0, 0, 1644, 0, 1644, 0, 0, - 0, 1644, 0, 0, 1916, 1916, 0, 0, 1644, 1644, - 0, 0, 0, 0, 1620, 0, 1644, 0, 0, 0, - 0, 729, 0, 0, 730, 1644, 0, 0, 0, 1631, - 0, 0, 0, 0, 1607, 731, 1621, 1608, 732, 0, - 1644, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 0, 0, - 0, 0, 0, 1622, 0, 0, 733, 0, 1623, 0, - 0, 0, 1616, 0, 0, 0, 0, 0, 0, 0, - 734, 0, 1618, 0, 0, 0, 735, 736, 1414, 1619, - 0, 1624, 1625, 0, 0, 0, 0, 737, 0, 0, - 0, 0, 0, 738, 0, 0, 1626, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1620, 0, 0, 0, - 1621, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 739, 0, 0, 0, 0, 0, 0, 1622, 0, 0, - 0, 0, 1623, 0, 1627, 0, 1632, 1628, 0, 1633, - 1634, 1635, 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, - 0, 1629, 0, 2058, 1630, 1624, 1625, 0, 0, 0, + 0, 0, 1625, 0, 0, 0, 0, 1626, 1630, 0, + 0, 1631, 0, 0, 0, 0, 0, 0, 0, 0, + 1415, 0, 0, 0, 0, 1632, 0, 0, 1633, 0, + 1627, 1628, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1629, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1626, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1624, 0, + 1364, 1365, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1630, 1635, 1625, 1631, 1636, 1637, 1638, + 1626, 1639, 1640, 1641, 1642, 1643, 1644, 0, 0, 0, + 1632, 2493, 0, 1633, 0, 0, 0, 0, 1364, 1365, + 0, 1366, 1367, 1627, 1628, 1368, 1369, 0, 0, 0, + 0, 0, 0, 0, 0, 1634, 0, 0, 1629, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1366, + 1367, 0, 0, 1368, 1369, 0, 0, 0, 0, 1919, + 1415, 0, 0, 0, 0, 0, 1630, 0, 0, 1631, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1621, 0, 0, 0, 0, 0, 1627, 0, - 0, 1628, 0, 0, 0, 0, 0, 1916, 1414, 1622, - 0, 0, 0, 0, 1623, 1629, 0, 0, 1630, 0, + 0, 0, 0, 1632, 1647, 1647, 1633, 0, 0, 0, + 1370, 1371, 0, 0, 0, 0, 0, 0, 0, 0, + 1634, 0, 0, 0, 0, 0, 0, 0, 1647, 0, + 0, 0, 1647, 0, 1647, 1647, 1647, 0, 0, 1647, + 0, 0, 1647, 1647, 0, 0, 0, 0, 1370, 1371, + 0, 1647, 1635, 0, 0, 1636, 1637, 1638, 0, 1639, + 1640, 1641, 1642, 1643, 1644, 0, 0, 0, 0, 2699, + 0, 0, 0, 0, 1372, 1373, 1374, 1375, 1376, 1377, + 1378, 1379, 0, 0, 1380, 1381, 0, 0, 0, 0, + 0, 0, 1647, 0, 0, 0, 0, 0, 1919, 0, + 0, 0, 0, 1634, 0, 0, 0, 0, 0, 0, + 0, 1647, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, + 0, 0, 1380, 1381, 0, 0, 0, 1635, 0, 0, + 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, + 0, 0, 0, 0, 2771, 1647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1644, 1644, 0, 0, 0, 1624, 1625, 0, - 0, 1631, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1626, 0, 0, 0, 0, 1644, 0, 0, - 0, 1644, 0, 1644, 1644, 1644, 0, 0, 1644, 0, - 0, 1644, 1644, 0, 0, 0, 0, 0, 0, 0, - 1644, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1627, 0, 0, 1628, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1629, 0, 0, - 1630, 0, 0, 0, 0, 1631, 0, 0, 0, 0, - 0, 1644, 0, 0, 0, 0, 0, 1916, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1644, 0, 0, 0, 0, 0, 0, 0, 1632, 0, - 0, 1633, 1634, 1635, 0, 1636, 1637, 1638, 1639, 1640, - 1641, 0, 0, 0, 0, 2363, 0, 0, 0, 0, - 0, 0, 0, 1644, 0, 0, 0, 0, 0, 0, + 0, 0, 1919, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1382, 1383, 0, + 0, 0, 0, 0, 0, 1647, 1647, 1647, 0, 0, + 1635, 0, 0, 1636, 1637, 1638, 0, 1639, 1640, 1641, + 1642, 1643, 1644, 0, 0, 1647, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1382, 1383, 1647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1916, 0, 0, 0, 0, 0, 1631, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1632, 0, 0, 1633, 1634, 1635, 0, 1636, - 1637, 1638, 1639, 1640, 1641, 1644, 1644, 1644, 0, 2462, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1644, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1644, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1647, 0, 0, 0, 0, 0, 0, + 0, 0, 1384, 1385, 0, 0, 0, 0, 0, 0, + 1647, 0, 0, 0, 0, 0, 0, 0, 0, 1647, + 0, 0, 0, 0, 0, 0, 1386, 1387, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1384, 1385, 0, 0, 1647, 0, 1993, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1386, 1387, 0, 0, 0, 0, + 1647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1644, 0, 1632, 0, 0, 1633, 1634, 1635, - 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, 0, 0, - 1644, 2486, 0, 0, 0, 0, 0, 0, 0, 0, - 1644, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 116, 1042, 815, 1043, + 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1647, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 1048, 0, 0, 128, 129, 130, 0, 131, + 132, 133, 134, 135, 136, 137, 138, 1049, 140, 1050, + 1051, 0, 143, 144, 145, 146, 147, 148, 1052, 785, + 149, 150, 151, 152, 1053, 1054, 155, 1647, 156, 157, + 158, 159, 786, 0, 787, 0, 1055, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 1056, 190, 191, 1057, 193, + 1058, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 1059, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 1060, 221, 222, 223, 224, + 225, 788, 1061, 227, 0, 228, 229, 1062, 231, 0, + 232, 0, 233, 234, 0, 235, 236, 237, 238, 239, + 240, 0, 241, 0, 1063, 1064, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 266, 267, 268, 269, 270, 271, 272, 1065, 1066, + 0, 1067, 0, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 288, 289, 290, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 1068, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 1069, 321, 1070, 323, 324, 325, 326, 1071, 327, 328, + 329, 330, 1072, 790, 332, 1073, 334, 335, 336, 0, + 337, 338, 0, 0, 1074, 340, 341, 0, 0, 342, + 343, 344, 345, 346, 347, 792, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 793, 363, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 1075, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 399, 400, 401, 402, 1076, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 426, 427, 428, 1077, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 795, 0, 0, 446, 447, 0, + 448, 449, 450, 451, 452, 453, 454, 0, 455, 1078, + 1079, 0, 0, 458, 459, 796, 461, 797, 1080, 463, + 464, 798, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 1081, 0, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 1082, 0, 0, 0, 0, 0, 0, 1083, 1084, + 1085, 0, 0, 0, 0, 1086, 0, 1087, 0, 0, + 0, 0, 1088, 1089, 0, 1090, 1091, 2624, 116, 1042, + 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, + 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, + 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, + 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, + 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, + 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, + 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, + 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, + 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, + 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, + 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, + 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, + 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, + 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, + 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, + 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, + 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, + 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, + 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, + 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, + 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, + 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, + 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, + 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, + 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, + 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, + 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, + 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, + 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, + 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, + 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, + 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, + 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, + 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, + 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, + 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, + 0, 0, 0, 0, 1088, 1089, 0, 1090, 1091, 3228, + 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, + 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, + 127, 0, 0, 0, 0, 0, 1048, 0, 0, 128, + 129, 130, 0, 131, 132, 133, 134, 135, 136, 137, + 138, 1049, 140, 1050, 1051, 0, 143, 144, 145, 146, + 147, 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, + 155, 0, 156, 157, 158, 159, 786, 0, 787, 0, + 1055, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 0, 172, 173, 174, 175, 176, 177, 0, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 1056, + 190, 191, 1057, 193, 1058, 194, 0, 195, 196, 197, + 198, 199, 200, 14, 15, 201, 202, 203, 204, 0, + 0, 205, 206, 1059, 208, 209, 0, 210, 211, 212, + 0, 213, 214, 215, 0, 216, 217, 218, 219, 1060, + 221, 222, 223, 224, 225, 788, 1061, 227, 0, 228, + 229, 1062, 231, 0, 232, 0, 233, 234, 23, 235, + 236, 237, 238, 239, 240, 0, 241, 0, 1063, 1064, + 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 0, 258, 259, 260, 261, + 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, + 271, 272, 1065, 1066, 0, 1067, 0, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 0, 0, + 287, 288, 289, 290, 0, 291, 292, 293, 294, 295, + 296, 297, 298, 1068, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 1069, 321, 1070, 323, 324, 325, + 326, 1071, 327, 328, 329, 330, 1072, 790, 332, 1073, + 334, 335, 336, 0, 337, 338, 0, 0, 1074, 340, + 341, 0, 0, 342, 343, 344, 345, 346, 347, 792, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 27, 28, 29, 0, 360, 361, 793, 363, 364, + 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, + 374, 375, 0, 376, 377, 378, 1075, 380, 381, 382, + 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 0, 397, 398, 399, 400, + 401, 402, 1076, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 34, 0, 417, 418, + 419, 420, 421, 422, 423, 424, 425, 36, 426, 427, + 428, 1077, 430, 0, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 795, 38, + 0, 446, 447, 39, 448, 449, 450, 451, 452, 453, + 454, 0, 455, 1078, 1079, 0, 0, 458, 459, 796, + 461, 797, 1080, 463, 464, 798, 466, 467, 468, 469, + 470, 0, 0, 471, 472, 473, 41, 474, 475, 476, + 477, 0, 478, 479, 480, 481, 482, 799, 1081, 0, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 0, + 0, 494, 0, 45, 495, 496, 497, 498, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 1082, 0, 46, 0, 0, + 0, 0, 1083, 1084, 1085, 0, 0, 0, 0, 1086, + 0, 1087, 3203, 0, 0, 0, 1088, 1089, 0, 1090, + 1091, 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 1048, 0, 0, + 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, + 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, 145, + 146, 147, 148, 1052, 785, 149, 150, 151, 152, 1053, + 1054, 155, 0, 156, 157, 158, 159, 786, 0, 787, + 0, 1055, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 1056, 190, 191, 1057, 193, 1058, 194, 0, 195, 196, + 197, 198, 199, 200, 14, 15, 201, 202, 203, 204, + 0, 0, 205, 206, 1059, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 1060, 221, 222, 223, 224, 225, 788, 1061, 227, 0, + 228, 229, 1062, 231, 0, 232, 0, 233, 234, 23, + 235, 236, 237, 238, 239, 240, 0, 241, 0, 1063, + 1064, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, + 270, 271, 272, 1065, 1066, 0, 1067, 0, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 288, 289, 290, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 1068, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 1069, 321, 1070, 323, 324, + 325, 326, 1071, 327, 328, 329, 330, 1072, 790, 332, + 1073, 334, 335, 336, 0, 337, 338, 0, 0, 1074, + 340, 341, 0, 0, 342, 343, 344, 345, 346, 347, + 792, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 27, 28, 29, 0, 360, 361, 793, 363, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 1075, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 399, + 400, 401, 402, 1076, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 34, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 36, 426, + 427, 428, 1077, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 795, + 38, 0, 446, 447, 39, 448, 449, 450, 451, 452, + 453, 454, 0, 455, 1078, 1079, 0, 0, 458, 459, + 796, 461, 797, 1080, 463, 464, 798, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 41, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 799, 1081, + 0, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 45, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 1082, 0, 46, 0, + 0, 0, 0, 1083, 1084, 1085, 0, 0, 0, 0, + 1086, 0, 1087, 0, 0, 0, 0, 1088, 1089, 0, + 1090, 1091, 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1644, 0, 0, 0, 0, + 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, + 125, 126, 127, 0, 0, 0, 0, 0, 1048, 0, + 0, 128, 129, 130, 0, 131, 132, 133, 134, 135, + 136, 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, + 145, 146, 147, 148, 1052, 785, 149, 150, 151, 152, + 1053, 1054, 155, 0, 156, 157, 158, 159, 786, 0, + 787, 0, 1055, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 1056, 190, 191, 1057, 193, 1058, 194, 0, 195, + 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, + 204, 0, 0, 205, 206, 1059, 208, 209, 0, 210, + 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, + 219, 1060, 221, 222, 223, 224, 225, 788, 1061, 227, + 0, 228, 229, 1062, 231, 0, 232, 0, 233, 234, + 23, 235, 236, 237, 238, 239, 240, 0, 241, 0, + 1063, 1064, 244, 245, 0, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 0, 258, 259, + 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, + 269, 270, 271, 272, 1065, 1066, 0, 1067, 0, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 0, 0, 287, 288, 289, 290, 0, 291, 292, 293, + 294, 295, 296, 297, 298, 1068, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 1069, 321, 1070, 323, + 324, 325, 326, 1071, 327, 328, 329, 330, 1072, 790, + 332, 1073, 334, 335, 336, 0, 337, 338, 0, 0, + 1074, 340, 341, 0, 0, 342, 343, 344, 345, 346, + 347, 792, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 27, 28, 29, 0, 360, 361, 793, + 363, 364, 365, 366, 367, 368, 369, 0, 370, 371, + 372, 373, 374, 375, 0, 376, 377, 378, 1075, 380, + 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, + 399, 400, 401, 402, 1076, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 34, 0, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, + 426, 427, 428, 1077, 430, 0, 431, 432, 433, 434, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 795, 0, 0, 446, 447, 39, 448, 449, 450, 451, + 452, 453, 454, 0, 455, 1078, 1079, 0, 0, 458, + 459, 796, 461, 797, 1080, 463, 464, 798, 466, 467, + 468, 469, 470, 0, 0, 471, 472, 473, 41, 474, + 475, 476, 477, 0, 478, 479, 480, 481, 482, 799, + 1081, 0, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 0, 0, 494, 0, 45, 495, 496, 497, 498, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 1082, 0, 46, + 0, 0, 0, 0, 1083, 1084, 1085, 0, 0, 0, + 0, 1086, 0, 1087, 0, 0, 0, 0, 1088, 1089, + 0, 1090, 1091, 1241, 1042, 815, 1043, 1044, 1045, 1046, + 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, + 1242, 125, 126, 127, 0, 0, 0, 1243, 0, 1048, + 0, 0, 1244, 129, 130, 0, 131, 132, 133, 1245, + 135, 136, 137, 138, 1049, 1246, 1050, 1051, 0, 143, + 144, 145, 146, 147, 148, 1052, 785, 149, 150, 151, + 152, 1053, 1054, 155, 0, 156, 157, 158, 159, 786, + 0, 1247, 0, 1248, 163, 164, 165, 166, 167, 1249, + 169, 170, 171, 0, 172, 173, 174, 175, 176, 177, + 0, 1250, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 1056, 190, 191, 1057, 193, 1058, 194, 0, + 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, + 203, 204, 1251, 0, 205, 206, 1059, 208, 209, 0, + 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, + 218, 219, 1060, 221, 222, 223, 224, 225, 788, 1061, + 227, 0, 228, 229, 1062, 231, 0, 232, 0, 233, + 1252, 0, 1253, 236, 237, 1254, 1255, 240, 0, 241, + 0, 1063, 1064, 244, 245, 0, 246, 247, 248, 249, + 250, 251, 252, 1256, 254, 255, 256, 257, 0, 258, + 259, 260, 261, 262, 263, 264, 0, 265, 1257, 267, + 268, 269, 270, 271, 272, 1065, 1066, 0, 1067, 0, + 276, 1258, 1259, 279, 1260, 281, 282, 283, 284, 285, + 286, 0, 0, 287, 1261, 289, 1262, 0, 291, 292, + 293, 294, 295, 296, 297, 298, 1263, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 1069, 1264, 1070, + 323, 324, 325, 326, 1071, 327, 328, 1265, 330, 1072, + 790, 332, 1073, 334, 335, 336, 0, 337, 338, 0, + 0, 1074, 340, 341, 0, 0, 342, 343, 344, 1266, + 346, 1267, 792, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 0, 0, 0, 0, 360, 361, + 793, 1268, 364, 365, 366, 367, 368, 369, 0, 370, + 371, 372, 373, 374, 375, 0, 376, 377, 378, 1075, + 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 0, 397, + 398, 1269, 400, 401, 402, 1076, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 0, + 1270, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 0, 1271, 427, 428, 1077, 430, 0, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 1272, + 444, 795, 0, 0, 446, 447, 0, 448, 1273, 450, + 451, 452, 453, 454, 0, 455, 1078, 1079, 0, 0, + 458, 459, 796, 461, 797, 1080, 463, 464, 1274, 466, + 467, 468, 469, 470, 0, 0, 471, 472, 473, 0, + 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, + 483, 1081, 1275, 485, 1276, 487, 488, 489, 490, 491, + 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, + 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, + 508, 509, 510, 511, 512, 513, 514, 515, 1082, 0, + 0, 0, 0, 0, 0, 1083, 1084, 1085, 0, 0, + 0, 0, 1086, 0, 1087, 1277, 0, 0, 0, 1088, + 1089, 0, 1090, 1091, 116, 1042, 815, 1043, 1044, 0, + 1046, 1047, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, + 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, + 1048, 0, 0, 128, 129, 130, 0, 131, 132, 133, + 134, 135, 136, 137, 138, 1049, 140, 1050, 1051, 0, + 143, 144, 145, 146, 147, 148, 1052, 785, 149, 150, + 151, 152, 1053, 1054, 155, 0, 156, 157, 158, 159, + 786, 0, 787, 0, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 0, 172, 173, 174, 175, 176, + 177, 0, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 1056, 190, 191, 1057, 193, 0, 194, + 0, 195, 196, 197, 198, 199, 200, 14, 15, 201, + 202, 203, 204, 0, 0, 205, 206, 1059, 208, 209, + 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, + 217, 218, 219, 1060, 221, 222, 223, 224, 225, 788, + 1061, 227, 0, 228, 229, 1062, 231, 0, 232, 0, + 233, 234, 23, 235, 236, 237, 238, 239, 240, 0, + 241, 0, 1063, 1064, 244, 245, 0, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 0, + 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, + 267, 268, 269, 270, 271, 272, 1065, 1066, 0, 1067, + 0, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 0, 0, 287, 288, 289, 290, 0, 291, + 292, 293, 294, 295, 296, 297, 298, 1068, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 1069, 321, + 1070, 323, 324, 325, 326, 0, 327, 328, 329, 330, + 1072, 790, 332, 1073, 334, 335, 336, 0, 337, 338, + 0, 0, 339, 340, 341, 0, 0, 342, 343, 344, + 345, 346, 347, 792, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 27, 28, 29, 0, 360, + 361, 793, 363, 364, 365, 366, 367, 368, 369, 0, + 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, + 1075, 380, 381, 382, 383, 0, 384, 385, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, + 397, 398, 399, 400, 401, 402, 1076, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 34, 0, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 36, 426, 427, 428, 1077, 430, 0, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 795, 38, 0, 446, 447, 39, 448, 449, + 450, 451, 452, 453, 454, 0, 455, 1078, 1079, 0, + 0, 458, 459, 796, 461, 797, 1080, 463, 464, 798, + 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, + 41, 474, 475, 476, 477, 0, 478, 479, 480, 481, + 482, 799, 1081, 0, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 0, 0, 494, 0, 45, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 0, + 0, 46, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1086, 0, 1087, 0, 0, 0, 0, + 1088, 1089, 0, 1090, 1091, 116, 1042, 815, 1043, 1044, + 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, + 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, + 0, 1048, 0, 0, 128, 129, 130, 0, 131, 132, + 133, 134, 135, 136, 137, 138, 1049, 140, 1050, 1051, + 1422, 143, 144, 145, 146, 147, 148, 1052, 785, 149, + 150, 151, 152, 1053, 1054, 155, 0, 156, 157, 158, + 159, 786, 0, 787, 0, 1055, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 0, 172, 173, 174, 175, + 176, 177, 0, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 1056, 190, 191, 1057, 193, 1058, + 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, + 201, 202, 203, 204, 0, 0, 205, 206, 1059, 208, + 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, + 216, 217, 218, 219, 1060, 221, 222, 223, 224, 225, + 788, 1061, 227, 0, 228, 229, 1062, 231, 0, 232, + 0, 233, 234, 1423, 235, 236, 237, 238, 239, 240, + 0, 241, 0, 1063, 1064, 244, 245, 0, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, + 266, 267, 268, 269, 270, 271, 272, 1065, 1066, 0, + 1067, 0, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 0, 1424, 287, 288, 289, 290, 0, + 291, 292, 293, 294, 295, 296, 297, 298, 1068, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 1069, + 321, 1070, 323, 324, 325, 326, 1071, 327, 328, 329, + 330, 1072, 790, 332, 1073, 334, 335, 336, 0, 337, + 338, 0, 0, 1074, 340, 341, 0, 0, 342, 343, + 344, 345, 346, 347, 792, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, + 360, 361, 793, 363, 364, 365, 366, 367, 368, 369, + 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, + 378, 1075, 380, 381, 382, 383, 0, 384, 385, 386, + 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 0, 397, 398, 399, 400, 401, 402, 1076, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, + 424, 425, 0, 426, 427, 428, 1077, 430, 0, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 795, 0, 0, 446, 447, 0, 448, + 449, 450, 451, 452, 453, 454, 0, 455, 1078, 1079, + 0, 1425, 458, 459, 796, 461, 797, 1080, 463, 464, + 798, 466, 467, 468, 469, 470, 0, 0, 471, 472, + 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, + 481, 482, 483, 1081, 0, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, + 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, + 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, + 1082, 0, 0, 0, 0, 0, 0, 1083, 1084, 1085, + 0, 0, 0, 0, 1086, 0, 1087, 0, 0, 0, + 0, 1088, 1089, 0, 1090, 1091, 1241, 1042, 815, 1043, + 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 1243, 0, 1048, 0, 0, 1244, 129, 130, 0, 131, + 132, 133, 1245, 135, 136, 137, 138, 1049, 1246, 1050, + 1051, 0, 143, 144, 145, 146, 147, 148, 1052, 785, + 149, 150, 151, 152, 1053, 1054, 155, 0, 156, 157, + 158, 159, 786, 0, 1247, 0, 1248, 163, 164, 165, + 166, 167, 1249, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 1250, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 1056, 190, 191, 1057, 193, + 1058, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 1059, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 1060, 221, 222, 223, 224, + 225, 788, 1061, 227, 0, 228, 229, 1062, 231, 0, + 232, 0, 233, 1252, 0, 1253, 236, 237, 1254, 1255, + 240, 0, 241, 0, 1063, 1064, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 1256, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 1257, 267, 268, 269, 270, 271, 272, 1065, 1066, + 0, 1067, 0, 276, 1258, 1259, 279, 1260, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 1261, 289, 1262, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 1263, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 1069, 1264, 1070, 323, 324, 325, 326, 1071, 327, 328, + 1265, 330, 1072, 790, 332, 1073, 334, 335, 336, 0, + 337, 338, 0, 0, 1074, 340, 341, 0, 0, 342, + 343, 344, 1266, 346, 1267, 792, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 793, 1268, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 1075, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 1269, 400, 401, 402, 1076, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 1270, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 1271, 427, 428, 1077, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 1272, 444, 795, 0, 0, 446, 447, 0, + 448, 1273, 450, 451, 452, 453, 454, 0, 455, 1078, + 1079, 0, 0, 458, 459, 796, 461, 797, 1080, 463, + 464, 1274, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 1081, 2277, 485, 1276, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 1082, 0, 0, 0, 0, 0, 0, 1083, 1084, + 1085, 0, 0, 0, 0, 1086, 0, 1087, 0, 0, + 0, 0, 1088, 1089, 0, 1090, 1091, 1241, 1042, 815, + 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, + 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, + 0, 1243, 0, 1048, 0, 0, 1244, 129, 130, 0, + 131, 132, 133, 1245, 135, 136, 137, 138, 1049, 1246, + 1050, 1051, 0, 143, 144, 145, 146, 147, 148, 1052, + 785, 149, 150, 151, 152, 1053, 1054, 155, 0, 156, + 157, 158, 159, 786, 0, 1247, 0, 1248, 163, 164, + 165, 166, 167, 1249, 169, 170, 171, 0, 172, 173, + 174, 175, 176, 177, 0, 1250, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 1056, 190, 191, 1057, + 193, 1058, 194, 0, 195, 196, 197, 198, 199, 200, + 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, + 1059, 208, 209, 0, 210, 211, 212, 0, 213, 214, + 215, 0, 216, 217, 218, 219, 1060, 221, 222, 223, + 224, 225, 788, 1061, 227, 0, 228, 229, 1062, 231, + 0, 232, 0, 233, 1252, 0, 1253, 236, 237, 1254, + 1255, 240, 0, 241, 0, 1063, 1064, 244, 245, 0, + 246, 247, 248, 249, 250, 251, 252, 1256, 254, 255, + 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, + 0, 265, 1257, 267, 268, 269, 270, 271, 272, 1065, + 1066, 0, 1067, 0, 276, 1258, 1259, 279, 1260, 281, + 282, 283, 284, 285, 286, 0, 0, 287, 1261, 289, + 1262, 0, 291, 292, 293, 294, 295, 296, 297, 298, + 1263, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 1069, 1264, 1070, 323, 324, 325, 326, 1071, 327, + 328, 1265, 330, 1072, 790, 332, 1073, 334, 335, 336, + 0, 337, 338, 0, 0, 1074, 340, 341, 0, 0, + 342, 343, 344, 1266, 346, 1267, 792, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, + 0, 0, 360, 361, 793, 1268, 364, 365, 366, 367, + 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, + 376, 377, 378, 1075, 380, 381, 382, 383, 0, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 0, 397, 398, 1269, 400, 401, 402, 1076, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 0, 1270, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 0, 1271, 427, 428, 1077, 430, + 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 1272, 444, 795, 0, 0, 446, 447, + 0, 448, 1273, 450, 451, 452, 453, 454, 0, 455, + 1078, 1079, 0, 0, 458, 459, 796, 461, 797, 1080, + 463, 464, 1274, 466, 467, 468, 469, 470, 0, 0, + 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, + 479, 480, 481, 482, 483, 1081, 0, 485, 1276, 487, + 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, + 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, + 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, + 514, 515, 1082, 0, 0, 0, 0, 0, 0, 1083, + 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, 2334, + 0, 0, 0, 1088, 1089, 0, 1090, 1091, 116, 1042, + 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, + 120, 121, 122, 123, 124, -1109, 125, 126, 127, 0, + 0, 0, 0, -1109, 1048, 0, 0, 128, 129, 130, + 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, + 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, + 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, + 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, + 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, + 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, + 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, + 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, + 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, + 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, + 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, + 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, + 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, + 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, + 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, + 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, + 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, + 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, + 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, + 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, + 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, + 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, + 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, + 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, + 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, + 430, -1109, 431, 432, 433, 434, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, + 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, + 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, + 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, + 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, + 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, + 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, + 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, + 0, 0, 0, 0, 1088, 1089, 0, 1090, 1091, 1241, + 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 117, 118, + 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, + 0, 0, 0, 1243, 0, 1048, 0, 0, 1244, 129, + 130, 0, 131, 132, 133, 1245, 135, 136, 137, 138, + 1049, 1246, 1050, 1051, 0, 143, 144, 145, 146, 147, + 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, + 0, 156, 157, 158, 159, 786, 0, 1247, 0, 1248, + 163, 164, 165, 166, 167, 1249, 169, 170, 171, 0, + 172, 173, 174, 175, 176, 177, 0, 1250, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 1056, 190, + 191, 1057, 193, 1058, 194, 0, 195, 196, 197, 198, + 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, + 205, 206, 1059, 208, 209, 0, 210, 211, 212, 0, + 213, 214, 215, 0, 216, 217, 218, 219, 1060, 221, + 222, 223, 224, 225, 788, 1061, 227, 0, 228, 229, + 1062, 231, 0, 232, 0, 233, 1252, 0, 1253, 236, + 237, 1254, 1255, 240, 0, 241, 0, 1063, 1064, 244, + 245, 0, 246, 247, 248, 249, 250, 251, 252, 1256, + 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, + 263, 264, 0, 265, 1257, 267, 268, 269, 270, 271, + 272, 1065, 1066, 0, 1067, 0, 276, 1258, 1259, 279, + 1260, 281, 282, 283, 284, 285, 286, 0, 0, 287, + 1261, 289, 1262, 0, 291, 292, 293, 294, 295, 296, + 297, 298, 1263, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 1069, 1264, 1070, 323, 324, 325, 326, + 1071, 327, 328, 1265, 330, 1072, 790, 332, 1073, 334, + 335, 336, 0, 337, 338, 0, 0, 1074, 340, 341, + 0, 0, 342, 343, 344, 1266, 346, 1267, 792, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 0, 0, 0, 0, 360, 361, 793, 1268, 364, 365, + 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, + 375, 0, 376, 377, 378, 1075, 380, 381, 382, 383, + 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 0, 397, 398, 1269, 400, 401, + 402, 1076, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 0, 1270, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 0, 1271, 427, 428, + 1077, 430, 0, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 1272, 444, 795, 0, 0, + 446, 447, 0, 448, 1273, 450, 451, 452, 453, 454, + 0, 455, 1078, 1079, 0, 0, 458, 459, 796, 461, + 797, 1080, 463, 464, 1274, 466, 467, 468, 469, 470, + 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, + 0, 478, 479, 480, 481, 482, 483, 1081, 0, 485, + 1276, 487, 488, 489, 490, 491, 492, 493, 0, 0, + 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 512, 513, 514, 515, 1082, 0, 0, 0, 0, 0, + 0, 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, + 1087, 3068, 0, 0, 0, 1088, 1089, 0, 1090, 1091, + 1241, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, + 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, + 127, 0, 0, 0, 1243, 0, 1048, 0, 0, 1244, + 129, 130, 0, 131, 132, 133, 1245, 135, 136, 137, + 138, 1049, 1246, 1050, 1051, 0, 143, 144, 145, 146, + 147, 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, + 155, 0, 156, 157, 158, 159, 786, 0, 1247, 0, + 1248, 163, 164, 165, 166, 167, 1249, 169, 170, 171, + 0, 172, 173, 174, 175, 176, 177, 0, 1250, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 1056, + 190, 191, 1057, 193, 1058, 194, 0, 195, 196, 197, + 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, + 0, 205, 206, 1059, 208, 209, 0, 210, 211, 212, + 0, 213, 214, 215, 0, 216, 217, 218, 219, 1060, + 221, 222, 223, 224, 225, 788, 1061, 227, 0, 228, + 229, 1062, 231, 0, 232, 0, 233, 1252, 0, 1253, + 236, 237, 1254, 1255, 240, 0, 241, 0, 1063, 1064, + 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, + 1256, 254, 255, 256, 257, 0, 258, 259, 260, 261, + 262, 263, 264, 0, 265, 1257, 267, 268, 269, 270, + 271, 272, 1065, 1066, 0, 1067, 0, 276, 1258, 1259, + 279, 1260, 281, 282, 283, 284, 285, 286, 0, 0, + 287, 1261, 289, 1262, 0, 291, 292, 293, 294, 295, + 296, 297, 298, 1263, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 1069, 1264, 1070, 323, 324, 325, + 326, 1071, 327, 328, 1265, 330, 1072, 790, 332, 1073, + 334, 335, 336, 0, 337, 338, 0, 0, 1074, 340, + 341, 0, 0, 342, 343, 344, 1266, 346, 1267, 792, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 0, 0, 0, 0, 360, 361, 793, 1268, 364, + 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, + 374, 375, 0, 376, 377, 378, 1075, 380, 381, 382, + 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 0, 397, 398, 1269, 400, + 401, 402, 1076, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 0, 1270, 417, 418, + 419, 420, 421, 422, 423, 424, 425, 0, 1271, 427, + 428, 1077, 430, 0, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 1272, 444, 795, 0, + 0, 446, 447, 0, 448, 1273, 450, 451, 452, 453, + 454, 0, 455, 1078, 1079, 0, 0, 458, 459, 796, + 461, 797, 1080, 463, 464, 1274, 466, 467, 468, 469, + 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, + 477, 0, 478, 479, 480, 481, 482, 483, 1081, 0, + 485, 1276, 487, 488, 489, 490, 491, 492, 493, 0, + 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 1082, 0, 0, 0, 0, + 0, 0, 1083, 1084, 1085, 0, 0, 0, 0, 1086, + 0, 1087, 0, 0, 0, 0, 1088, 1089, 0, 1090, + 1091, 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 1688, 125, + 126, 127, 0, 0, 0, 0, 0, 1048, 0, 0, + 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, + 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, 145, + 146, 147, 148, 1052, 785, 149, 150, 151, 152, 1053, + 1054, 155, 0, 156, 157, 158, 159, 786, 0, 787, + 0, 1055, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 1056, 190, 191, 1057, 193, 1058, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 1059, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 1060, 221, 222, 223, 224, 225, 788, 1061, 227, 0, + 228, 229, 1062, 231, 0, 232, 0, 233, 234, 0, + 235, 236, 237, 238, 239, 240, 0, 241, 0, 1063, + 1064, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, + 270, 271, 272, 1065, 1066, 0, 1067, 0, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 288, 289, 290, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 1068, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 1069, 321, 1070, 323, 324, + 325, 326, 1071, 327, 328, 329, 330, 1072, 790, 332, + 1073, 334, 335, 336, 0, 337, 338, 0, 0, 1074, + 340, 341, 0, 0, 342, 343, 344, 345, 346, 347, + 792, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 793, 363, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 1075, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 399, + 400, 401, 402, 1076, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 426, + 427, 428, 1077, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 795, + 0, 0, 446, 447, 0, 448, 449, 450, 451, 452, + 453, 454, 0, 455, 1078, 1079, 0, 0, 458, 459, + 796, 461, 797, 1080, 463, 464, 798, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 1081, + 0, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 1082, 0, 0, 0, + 0, 0, 0, 1083, 1084, 1085, 0, 0, 0, 0, + 1086, 0, 1087, 0, 0, 0, 0, 1088, 1089, 0, + 1090, 1091, 116, 1703, 815, 1043, 1044, 1045, 1704, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1644, 0, 116, 1042, 815, 1043, 1044, 1045, 1046, + 0, 117, 118, 119, 120, 121, 122, 123, 124, 1705, + 125, 126, 127, 0, 0, 0, 0, 0, 1048, 0, + 0, 128, 129, 130, 0, 131, 132, 133, 134, 135, + 136, 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, + 145, 146, 147, 148, 1052, 785, 149, 150, 151, 152, + 1053, 1054, 155, 0, 156, 157, 158, 159, 786, 0, + 787, 0, 1055, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 1056, 190, 191, 1057, 193, 1058, 194, 0, 195, + 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, + 204, 0, 0, 205, 206, 1059, 208, 209, 0, 210, + 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, + 219, 1060, 221, 222, 223, 224, 225, 788, 1061, 227, + 0, 228, 229, 1062, 231, 0, 232, 0, 233, 234, + 0, 235, 236, 237, 238, 239, 240, 0, 241, 0, + 1063, 1064, 244, 245, 0, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 0, 258, 259, + 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, + 269, 270, 271, 272, 1065, 1066, 0, 1067, 0, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 0, 0, 287, 288, 289, 290, 0, 291, 292, 293, + 294, 295, 296, 297, 298, 1068, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 1069, 321, 1070, 323, + 324, 325, 326, 1071, 327, 328, 329, 330, 1072, 790, + 332, 1073, 334, 335, 336, 0, 337, 338, 0, 0, + 1074, 340, 341, 0, 0, 342, 343, 344, 345, 346, + 347, 792, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 0, 0, 0, 0, 360, 361, 793, + 363, 364, 365, 366, 367, 368, 369, 0, 370, 371, + 372, 373, 374, 375, 0, 376, 377, 378, 1075, 380, + 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, + 399, 400, 401, 402, 1076, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, + 426, 427, 428, 1077, 430, 0, 431, 432, 433, 434, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 795, 0, 0, 446, 447, 0, 448, 449, 450, 451, + 452, 453, 454, 0, 455, 1078, 1079, 0, 0, 458, + 459, 796, 461, 797, 1080, 463, 464, 798, 466, 467, + 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, + 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, + 1081, 0, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 1082, 0, 0, + 0, 0, 0, 0, 1083, 1084, 1085, 0, 0, 0, + 0, 1086, 0, 1087, 0, 0, 0, 0, 1088, 1089, + 0, 1090, 1091, 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, 1048, - 0, 0, 128, 129, 130, 1644, 131, 132, 133, 134, + 0, 0, 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, 173, 174, 175, 176, 177, - 1644, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 0, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, 231, 0, 232, 0, 233, - 234, 0, 235, 236, 237, 238, 239, 240, 0, 241, + 234, 1423, 235, 236, 237, 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, @@ -390432,7 +395953,59 @@ static const yytype_int16 yytable[] = 508, 509, 510, 511, 512, 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, 0, 0, 0, 0, 1088, - 1089, 1090, 1091, 0, 2617, 116, 1042, 815, 1043, 1044, + 1089, 0, 1090, 1091, 116, 1042, 815, 1043, 1044, 1045, + 1046, 1047, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, + 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, + 1048, 0, 0, 128, 129, 130, 0, 131, 132, 133, + 134, 135, 136, 137, 138, 1049, 140, 1050, 1051, 0, + 143, 144, 145, 146, 147, 148, 1052, 785, 149, 150, + 151, 152, 1053, 1054, 155, 0, 156, 157, 158, 159, + 786, 0, 787, 0, 1055, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 0, 172, 173, 174, 175, 176, + 177, 0, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 1056, 190, 191, 1057, 193, 1058, 194, + 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, + 202, 203, 204, 0, 0, 205, 206, 1059, 208, 209, + 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, + 217, 218, 219, 1060, 221, 222, 223, 224, 225, 788, + 1061, 227, 0, 228, 229, 1062, 231, 0, 232, 0, + 233, 234, 0, 235, 236, 237, 238, 239, 240, 0, + 241, 0, 1063, 1064, 244, 245, 0, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 0, + 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, + 267, 268, 269, 270, 271, 272, 1065, 1066, 0, 1067, + 0, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 0, 0, 287, 288, 289, 290, 0, 291, + 292, 293, 294, 295, 296, 297, 298, 1068, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 1069, 321, + 1070, 323, 324, 325, 326, 1071, 327, 328, 329, 330, + 1072, 790, 332, 1073, 334, 335, 336, 0, 337, 338, + 0, 0, 1074, 340, 341, 0, 0, 342, 343, 344, + 345, 346, 347, 792, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, + 361, 793, 363, 364, 365, 366, 367, 368, 369, 0, + 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, + 1075, 380, 381, 382, 383, 0, 384, 385, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, + 397, 398, 399, 400, 401, 402, 1076, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 0, 426, 427, 428, 1077, 430, 0, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 795, 0, 0, 446, 447, 0, 448, 449, + 450, 451, 452, 453, 454, 0, 455, 1078, 1079, 0, + 0, 458, 459, 796, 461, 797, 1080, 463, 464, 798, + 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, + 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, + 482, 483, 1081, 0, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 1082, + 0, 0, 0, 0, 0, 0, 1083, 1084, 1085, 0, + 0, 0, 0, 1086, 0, 1087, 2051, 0, 0, 0, + 1088, 1089, 0, 1090, 1091, 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, @@ -390473,7 +396046,7 @@ static const yytype_int16 yytable[] = 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 795, 0, 0, 446, 447, 0, 448, + 442, 443, 444, 795, 0, 0, 446, 447, 2678, 448, 449, 450, 451, 452, 453, 454, 0, 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, 0, 471, 472, @@ -390484,129 +396057,77 @@ static const yytype_int16 yytable[] = 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, 0, 0, 0, - 0, 1088, 1089, 1090, 1091, 0, 3223, 116, 1042, 815, - 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, - 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, - 0, 0, 0, 1048, 0, 0, 128, 129, 130, 0, - 131, 132, 133, 134, 135, 136, 137, 138, 1049, 140, - 1050, 1051, 0, 143, 144, 145, 146, 147, 148, 1052, - 785, 149, 150, 151, 152, 1053, 1054, 155, 0, 156, - 157, 158, 159, 786, 0, 787, 0, 1055, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 0, 172, 173, - 174, 175, 176, 177, 0, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 1056, 190, 191, 1057, - 193, 1058, 194, 0, 195, 196, 197, 198, 199, 200, - 14, 15, 201, 202, 203, 204, 0, 0, 205, 206, - 1059, 208, 209, 0, 210, 211, 212, 0, 213, 214, - 215, 0, 216, 217, 218, 219, 1060, 221, 222, 223, - 224, 225, 788, 1061, 227, 0, 228, 229, 1062, 231, - 0, 232, 0, 233, 234, 23, 235, 236, 237, 238, - 239, 240, 0, 241, 0, 1063, 1064, 244, 245, 0, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, - 0, 265, 266, 267, 268, 269, 270, 271, 272, 1065, - 1066, 0, 1067, 0, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 0, 0, 287, 288, 289, - 290, 0, 291, 292, 293, 294, 295, 296, 297, 298, - 1068, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, 327, - 328, 329, 330, 1072, 790, 332, 1073, 334, 335, 336, - 0, 337, 338, 0, 0, 1074, 340, 341, 0, 0, - 342, 343, 344, 345, 346, 347, 792, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 27, 28, - 29, 0, 360, 361, 793, 363, 364, 365, 366, 367, - 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, - 376, 377, 378, 1075, 380, 381, 382, 383, 0, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 0, 397, 398, 399, 400, 401, 402, 1076, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 34, 0, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 36, 426, 427, 428, 1077, 430, - 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 795, 38, 0, 446, 447, - 39, 448, 449, 450, 451, 452, 453, 454, 0, 455, - 1078, 1079, 0, 0, 458, 459, 796, 461, 797, 1080, - 463, 464, 798, 466, 467, 468, 469, 470, 0, 0, - 471, 472, 473, 41, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 799, 1081, 0, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, - 45, 495, 496, 497, 498, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 1082, 0, 46, 0, 0, 0, 0, 1083, - 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, 3197, - 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, 815, - 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, - 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, - 0, 0, 0, 1048, 0, 0, 128, 129, 130, 0, - 131, 132, 133, 134, 135, 136, 137, 138, 1049, 140, - 1050, 1051, 0, 143, 144, 145, 146, 147, 148, 1052, - 785, 149, 150, 151, 152, 1053, 1054, 155, 0, 156, - 157, 158, 159, 786, 0, 787, 0, 1055, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 0, 172, 173, - 174, 175, 176, 177, 0, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 1056, 190, 191, 1057, - 193, 1058, 194, 0, 195, 196, 197, 198, 199, 200, - 14, 15, 201, 202, 203, 204, 0, 0, 205, 206, - 1059, 208, 209, 0, 210, 211, 212, 0, 213, 214, - 215, 0, 216, 217, 218, 219, 1060, 221, 222, 223, - 224, 225, 788, 1061, 227, 0, 228, 229, 1062, 231, - 0, 232, 0, 233, 234, 23, 235, 236, 237, 238, - 239, 240, 0, 241, 0, 1063, 1064, 244, 245, 0, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, - 0, 265, 266, 267, 268, 269, 270, 271, 272, 1065, - 1066, 0, 1067, 0, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 0, 0, 287, 288, 289, - 290, 0, 291, 292, 293, 294, 295, 296, 297, 298, - 1068, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, 327, - 328, 329, 330, 1072, 790, 332, 1073, 334, 335, 336, - 0, 337, 338, 0, 0, 1074, 340, 341, 0, 0, - 342, 343, 344, 345, 346, 347, 792, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 27, 28, - 29, 0, 360, 361, 793, 363, 364, 365, 366, 367, - 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, - 376, 377, 378, 1075, 380, 381, 382, 383, 0, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 0, 397, 398, 399, 400, 401, 402, 1076, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 34, 0, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 36, 426, 427, 428, 1077, 430, - 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 795, 38, 0, 446, 447, - 39, 448, 449, 450, 451, 452, 453, 454, 0, 455, - 1078, 1079, 0, 0, 458, 459, 796, 461, 797, 1080, - 463, 464, 798, 466, 467, 468, 469, 470, 0, 0, - 471, 472, 473, 41, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 799, 1081, 0, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, - 45, 495, 496, 497, 498, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 1082, 0, 46, 0, 0, 0, 0, 1083, - 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, 0, - 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, 815, + 0, 1088, 1089, 0, 1090, 1091, 116, 1042, 815, 1043, + 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 1048, 0, 0, 128, 129, 130, 0, 131, + 132, 133, 134, 135, 136, 137, 138, 1049, 140, 1050, + 1051, 0, 143, 144, 145, 146, 147, 148, 1052, 785, + 149, 150, 151, 152, 1053, 1054, 155, 0, 156, 157, + 158, 159, 786, 0, 787, 0, 1055, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 1056, 190, 191, 1057, 193, + 1058, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 1059, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 1060, 221, 222, 223, 224, + 225, 788, 1061, 227, 0, 228, 229, 1062, 231, 0, + 232, 0, 233, 234, 0, 235, 236, 237, 238, 239, + 240, 0, 241, 0, 1063, 1064, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 266, 267, 268, 269, 270, 271, 272, 1065, 1066, + 0, 1067, 0, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 288, 289, 290, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 1068, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 1069, 321, 1070, 323, 324, 325, 326, 1071, 327, 328, + 329, 330, 1072, 790, 332, 1073, 334, 335, 336, 0, + 337, 338, 0, 0, 1074, 340, 341, 0, 0, 342, + 343, 344, 345, 346, 347, 792, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 793, 363, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 1075, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 399, 400, 401, 402, 1076, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 426, 427, 428, 1077, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 795, 0, 0, 446, 447, 0, + 448, 449, 450, 451, 452, 453, 454, 0, 455, 1078, + 1079, 0, 0, 458, 459, 796, 461, 797, 1080, 463, + 464, 798, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 1081, 0, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 0, 2797, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 1082, 0, 0, 0, 0, 0, 0, 1083, 1084, + 1085, 0, 0, 0, 0, 1086, 0, 1087, 0, 0, + 0, 0, 1088, 1089, 0, 1090, 1091, 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, - 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, + 121, 122, 123, 124, 3012, 125, 126, 127, 0, 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, 173, - 174, 175, 176, 177, 0, 178, 179, 180, 181, 182, + 174, 175, 176, 177, 0, 178, 179, 3013, 181, 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, 231, - 0, 232, 0, 233, 234, 23, 235, 236, 237, 238, - 239, 240, 0, 241, 0, 1063, 1064, 244, 245, 0, + 0, 232, 0, 233, 234, 0, 235, 236, 237, 238, + 239, 240, 0, 241, 0, 3014, 1064, 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, 1065, @@ -390619,136 +396140,34 @@ static const yytype_int16 yytable[] = 328, 329, 330, 1072, 790, 332, 1073, 334, 335, 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 27, 28, - 29, 0, 360, 361, 793, 363, 364, 365, 366, 367, + 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, + 0, 0, 360, 361, 793, 363, 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 0, 397, 398, 399, 400, 401, 402, 1076, + 395, 396, 0, 397, 398, 399, 400, 401, 3015, 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 34, 0, 417, 418, 419, 420, 421, + 414, 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, 447, - 39, 448, 449, 450, 451, 452, 453, 454, 0, 455, + 0, 448, 449, 450, 451, 452, 453, 454, 0, 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, 0, - 471, 472, 473, 41, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 799, 1081, 0, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, - 45, 495, 496, 497, 498, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 1082, 0, 46, 0, 0, 0, 0, 1083, - 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, 0, - 0, 0, 0, 1088, 1089, 1090, 1091, 1240, 1042, 815, - 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, - 121, 122, 123, 124, 1241, 125, 126, 127, 0, 0, - 0, 1242, 0, 1048, 0, 0, 1243, 129, 130, 0, - 131, 132, 133, 1244, 135, 136, 137, 138, 1049, 1245, - 1050, 1051, 0, 143, 144, 145, 146, 147, 148, 1052, - 785, 149, 150, 151, 152, 1053, 1054, 155, 0, 156, - 157, 158, 159, 786, 0, 1246, 0, 1247, 163, 164, - 165, 166, 167, 1248, 169, 170, 171, 0, 172, 173, - 174, 175, 176, 177, 0, 1249, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 1056, 190, 191, 1057, - 193, 1058, 194, 0, 195, 196, 197, 198, 199, 200, - 0, 0, 201, 202, 203, 204, 1250, 0, 205, 206, - 1059, 208, 209, 0, 210, 211, 212, 0, 213, 214, - 215, 0, 216, 217, 218, 219, 1060, 221, 222, 223, - 224, 225, 788, 1061, 227, 0, 228, 229, 1062, 231, - 0, 232, 0, 233, 1251, 0, 1252, 236, 237, 1253, - 1254, 240, 0, 241, 0, 1063, 1064, 244, 245, 0, - 246, 247, 248, 249, 250, 251, 252, 1255, 254, 255, - 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, - 0, 265, 1256, 267, 268, 269, 270, 271, 272, 1065, - 1066, 0, 1067, 0, 276, 1257, 1258, 279, 1259, 281, - 282, 283, 284, 285, 286, 0, 0, 287, 1260, 289, - 1261, 0, 291, 292, 293, 294, 295, 296, 297, 298, - 1262, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 1069, 1263, 1070, 323, 324, 325, 326, 1071, 327, - 328, 1264, 330, 1072, 790, 332, 1073, 334, 335, 336, - 0, 337, 338, 0, 0, 1074, 340, 341, 0, 0, - 342, 343, 344, 1265, 346, 1266, 792, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, - 0, 0, 360, 361, 793, 1267, 364, 365, 366, 367, - 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, - 376, 377, 378, 1075, 380, 381, 382, 383, 0, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 0, 397, 398, 1268, 400, 401, 402, 1076, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 0, 1269, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 0, 1270, 427, 428, 1077, 430, - 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 1271, 444, 795, 0, 0, 446, 447, - 0, 448, 1272, 450, 451, 452, 453, 454, 0, 455, - 1078, 1079, 0, 0, 458, 459, 796, 461, 797, 1080, - 463, 464, 1273, 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 483, 1081, 1274, 485, 1275, 487, + 479, 480, 481, 482, 483, 1081, 0, 485, 486, 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, 1083, - 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, 1276, - 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, 815, - 1043, 1044, 0, 1046, 1047, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, - 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, - 0, 0, 0, 1048, 0, 0, 128, 129, 130, 0, - 131, 132, 133, 134, 135, 136, 137, 138, 1049, 140, - 1050, 1051, 0, 143, 144, 145, 146, 147, 148, 1052, - 785, 149, 150, 151, 152, 1053, 1054, 155, 0, 156, - 157, 158, 159, 786, 0, 787, 0, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 0, 172, 173, - 174, 175, 176, 177, 0, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 1056, 190, 191, 1057, - 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, - 14, 15, 201, 202, 203, 204, 0, 0, 205, 206, - 1059, 208, 209, 0, 210, 211, 212, 0, 213, 214, - 215, 0, 216, 217, 218, 219, 1060, 221, 222, 223, - 224, 225, 788, 1061, 227, 0, 228, 229, 1062, 231, - 0, 232, 0, 233, 234, 23, 235, 236, 237, 238, - 239, 240, 0, 241, 0, 1063, 1064, 244, 245, 0, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, - 0, 265, 266, 267, 268, 269, 270, 271, 272, 1065, - 1066, 0, 1067, 0, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 0, 0, 287, 288, 289, - 290, 0, 291, 292, 293, 294, 295, 296, 297, 298, - 1068, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 1069, 321, 1070, 323, 324, 325, 326, 0, 327, - 328, 329, 330, 1072, 790, 332, 1073, 334, 335, 336, - 0, 337, 338, 0, 0, 339, 340, 341, 0, 0, - 342, 343, 344, 345, 346, 347, 792, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 27, 28, - 29, 0, 360, 361, 793, 363, 364, 365, 366, 367, - 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, - 376, 377, 378, 1075, 380, 381, 382, 383, 0, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 0, 397, 398, 399, 400, 401, 402, 1076, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 34, 0, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 36, 426, 427, 428, 1077, 430, - 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 795, 38, 0, 446, 447, - 39, 448, 449, 450, 451, 452, 453, 454, 0, 455, - 1078, 1079, 0, 0, 458, 459, 796, 461, 797, 1080, - 463, 464, 798, 466, 467, 468, 469, 470, 0, 0, - 471, 472, 473, 41, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 799, 1081, 0, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, - 45, 495, 496, 497, 498, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 0, 0, 46, 0, 0, 0, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 1086, 0, 1087, 0, - 0, 0, 0, 1088, 1089, 1090, 1091, 117, 118, 119, + 1084, 1085, 0, 0, 0, 0, 1086, 0, 3016, 0, + 0, 0, 0, 1088, 1089, 0, 1090, 1091, 116, 1042, + 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 1421, 143, 144, 145, 146, 147, 148, + 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, @@ -390759,13 +396178,13 @@ static const yytype_int16 yytable[] = 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 1422, 235, 236, 237, + 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 1423, 287, 288, + 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, @@ -390784,8 +396203,8 @@ static const yytype_int16 yytable[] = 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 1424, 458, 459, 796, 461, 797, + 447, 3164, 448, 449, 450, 451, 452, 453, 454, 0, + 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, @@ -390794,277 +396213,486 @@ static const yytype_int16 yytable[] = 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 1240, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 1242, 0, 1048, 0, 0, 1243, 129, 130, - 0, 131, 132, 133, 1244, 135, 136, 137, 138, 1049, - 1245, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 1246, 0, 1247, 163, - 164, 165, 166, 167, 1248, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 1249, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 1251, 0, 1252, 236, 237, - 1253, 1254, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 1255, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 1256, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 1257, 1258, 279, 1259, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 1260, - 289, 1261, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1262, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 1263, 1070, 323, 324, 325, 326, 1071, - 327, 328, 1264, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 1265, 346, 1266, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 1267, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 1268, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 1269, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 1270, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 1271, 444, 795, 0, 0, 446, - 447, 0, 448, 1272, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 1273, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 2272, 485, 1275, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 1240, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 1242, 0, 1048, 0, 0, 1243, 129, 130, - 0, 131, 132, 133, 1244, 135, 136, 137, 138, 1049, - 1245, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 1246, 0, 1247, 163, - 164, 165, 166, 167, 1248, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 1249, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 1251, 0, 1252, 236, 237, - 1253, 1254, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 1255, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 1256, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 1257, 1258, 279, 1259, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 1260, - 289, 1261, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1262, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 1263, 1070, 323, 324, 325, 326, 1071, - 327, 328, 1264, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 1265, 346, 1266, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 1267, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 1268, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 1269, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 1270, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 1271, 444, 795, 0, 0, 446, - 447, 0, 448, 1272, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 1273, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 1275, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 2326, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, -1106, 125, 126, 127, 0, - 0, 0, 0, -1106, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, -1106, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 1240, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 1242, 0, 1048, 0, 0, 1243, 129, 130, - 0, 131, 132, 133, 1244, 135, 136, 137, 138, 1049, - 1245, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 1246, 0, 1247, 163, - 164, 165, 166, 167, 1248, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 1249, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 1251, 0, 1252, 236, 237, - 1253, 1254, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 1255, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 1256, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 1257, 1258, 279, 1259, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 1260, - 289, 1261, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1262, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 1263, 1070, 323, 324, 325, 326, 1071, - 327, 328, 1264, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 1265, 346, 1266, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 1267, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 1268, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 1269, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 1270, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 1271, 444, 795, 0, 0, 446, - 447, 0, 448, 1272, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 1273, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 1275, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 3062, 0, 0, 0, 1088, 1089, 1090, 1091, 1240, 1042, + 0, 0, 0, 0, 1088, 1089, 0, 1090, 1091, 116, + 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 117, 118, + 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, + 0, 0, 0, 0, 0, 1048, 0, 0, 128, 129, + 130, 0, 131, 132, 133, 134, 135, 136, 137, 138, + 1049, 140, 1050, 1051, 0, 143, 144, 145, 146, 147, + 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, + 0, 156, 157, 158, 159, 786, 0, 787, 0, 1055, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 0, + 172, 173, 174, 175, 176, 177, 0, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 1056, 190, + 191, 1057, 193, 1058, 194, 0, 195, 196, 197, 198, + 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, + 205, 206, 1059, 208, 209, 0, 210, 211, 212, 0, + 213, 214, 215, 0, 216, 217, 218, 219, 1060, 221, + 222, 223, 224, 225, 788, 1061, 227, 0, 228, 229, + 1062, 231, 0, 232, 0, 233, 234, 0, 235, 236, + 237, 238, 239, 240, 0, 241, 0, 1063, 1064, 244, + 245, 0, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, + 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, + 272, 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 0, 0, 287, + 288, 289, 290, 0, 291, 292, 293, 294, 295, 296, + 297, 298, 1068, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 1069, 321, 1070, 323, 324, 325, 326, + 1071, 327, 328, 329, 330, 1072, 790, 332, 1073, 334, + 335, 336, 0, 337, 338, 0, 0, 1074, 340, 341, + 0, 0, 342, 343, 344, 345, 346, 347, 792, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 0, 0, 0, 0, 360, 361, 793, 363, 364, 365, + 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, + 375, 0, 376, 377, 378, 1075, 380, 381, 382, 383, + 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 0, 397, 398, 399, 400, 401, + 402, 1076, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 0, 0, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 0, 426, 427, 428, + 1077, 430, 0, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 795, 0, 0, + 446, 447, 3302, 448, 449, 450, 451, 452, 453, 454, + 0, 455, 1078, 1079, 0, 0, 458, 459, 796, 461, + 797, 1080, 463, 464, 798, 466, 467, 468, 469, 470, + 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, + 0, 478, 479, 480, 481, 482, 483, 1081, 0, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 0, 0, + 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 512, 513, 514, 515, 1082, 0, 0, 0, 0, 0, + 0, 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, + 1087, 0, 0, 0, 0, 1088, 1089, 0, 1090, 1091, + 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, + 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, + 127, 0, 0, 0, 0, 0, 1048, 0, 0, 128, + 129, 130, 0, 131, 132, 133, 134, 135, 136, 137, + 138, 1049, 140, 1050, 1051, 0, 143, 144, 145, 146, + 147, 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, + 155, 0, 156, 157, 158, 159, 786, 0, 787, 0, + 1055, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 0, 172, 173, 174, 175, 176, 177, 0, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 1056, + 190, 191, 1057, 193, 1058, 194, 0, 195, 196, 197, + 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, + 0, 205, 206, 1059, 208, 209, 0, 210, 211, 212, + 0, 213, 214, 215, 0, 216, 217, 218, 219, 1060, + 221, 222, 223, 224, 225, 788, 1061, 227, 0, 228, + 229, 1062, 231, 0, 232, 0, 233, 234, 0, 235, + 236, 237, 238, 239, 240, 0, 241, 0, 1063, 1064, + 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 0, 258, 259, 260, 261, + 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, + 271, 272, 1065, 1066, 0, 1067, 0, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 0, 0, + 287, 288, 289, 290, 0, 291, 292, 293, 294, 295, + 296, 297, 298, 1068, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 1069, 321, 1070, 323, 324, 325, + 326, 1071, 327, 328, 329, 330, 1072, 790, 332, 1073, + 334, 335, 336, 0, 337, 338, 0, 0, 1074, 340, + 341, 0, 0, 342, 343, 344, 345, 346, 347, 792, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 0, 0, 0, 0, 360, 361, 793, 363, 364, + 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, + 374, 375, 0, 376, 377, 378, 1075, 380, 381, 382, + 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 0, 397, 398, 399, 400, + 401, 402, 1076, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, + 419, 420, 421, 422, 423, 424, 425, 0, 426, 427, + 428, 1077, 430, 0, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 795, 0, + 0, 446, 447, 0, 448, 449, 450, 451, 452, 453, + 454, 0, 455, 1078, 1079, 0, 0, 458, 459, 796, + 461, 797, 1080, 463, 464, 798, 466, 467, 468, 469, + 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, + 477, 0, 478, 479, 480, 481, 482, 483, 1081, 0, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 0, + 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 1082, 0, 0, 0, 0, + 0, 0, 1083, 1084, 1085, 0, 0, 0, 0, 1086, + 0, 1087, 0, 0, 0, 0, 1088, 1089, 0, 1090, + 1091, 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 1048, 0, 0, + 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, + 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, 145, + 146, 147, 148, 1052, 785, 149, 150, 151, 152, 1053, + 1054, 155, 0, 156, 157, 158, 159, 786, 0, 787, + 0, 1055, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 1056, 190, 191, 1057, 193, 1058, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 1059, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 1060, 221, 222, 223, 224, 225, 788, 1061, 227, 0, + 228, 229, 1062, 231, 0, 232, 0, 233, 234, 0, + 235, 236, 237, 238, 239, 240, 0, 241, 0, 1063, + 1064, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, + 270, 271, 272, 1065, 1066, 0, 1067, 0, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 288, 289, 290, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 1068, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 1069, 321, 1070, 323, 324, + 325, 326, 1071, 327, 328, 329, 330, 1072, 790, 332, + 1073, 334, 335, 336, 0, 337, 338, 0, 0, 1074, + 340, 341, 0, 0, 342, 343, 344, 345, 346, 347, + 792, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 793, 363, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 1075, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 399, + 400, 401, 402, 1076, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 426, + 427, 428, 1077, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 795, + 0, 0, 446, 447, 0, 448, 449, 450, 451, 452, + 453, 454, 0, 455, 1078, 1079, 0, 0, 458, 459, + 796, 461, 797, 1080, 463, 464, 798, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 1081, + 0, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 1082, 0, 0, 0, + 0, 0, 0, 1708, 1709, 1085, 0, 0, 0, 0, + 1086, 0, 1087, 0, 0, 0, 0, 1088, 1089, 0, + 1090, 1091, 116, 2188, 815, 1043, 1044, 1045, 1046, 1047, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, + 125, 126, 127, 0, 0, 0, 0, 0, 1048, 0, + 0, 128, 129, 130, 0, 131, 132, 133, 134, 135, + 136, 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, + 145, 146, 147, 148, 1052, 785, 149, 150, 151, 152, + 1053, 1054, 155, 0, 156, 157, 158, 159, 786, 0, + 787, 0, 1055, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 1056, 190, 191, 1057, 193, 1058, 194, 0, 195, + 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, + 204, 0, 0, 205, 206, 1059, 208, 209, 0, 210, + 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, + 219, 1060, 221, 222, 223, 224, 225, 788, 1061, 227, + 0, 228, 229, 1062, 231, 0, 232, 0, 233, 234, + 0, 235, 236, 237, 238, 239, 240, 0, 241, 0, + 1063, 1064, 244, 245, 0, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 0, 258, 259, + 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, + 269, 270, 271, 272, 1065, 1066, 0, 1067, 0, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 0, 0, 287, 288, 289, 290, 0, 291, 292, 293, + 294, 295, 296, 297, 298, 1068, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 1069, 321, 1070, 323, + 324, 325, 326, 1071, 327, 328, 329, 330, 1072, 790, + 332, 1073, 334, 335, 336, 0, 337, 338, 0, 0, + 1074, 340, 341, 0, 0, 342, 343, 344, 345, 346, + 347, 792, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 0, 0, 0, 0, 360, 361, 793, + 363, 364, 365, 366, 367, 368, 369, 0, 370, 371, + 372, 373, 374, 375, 0, 376, 377, 378, 1075, 380, + 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, + 399, 400, 401, 402, 1076, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, + 426, 427, 428, 1077, 430, 0, 431, 432, 433, 434, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 795, 0, 0, 446, 447, 0, 448, 449, 450, 451, + 452, 453, 454, 0, 455, 1078, 1079, 0, 0, 458, + 459, 796, 461, 797, 1080, 463, 464, 798, 466, 467, + 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, + 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, + 1081, 0, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 1082, 0, 0, + 0, 0, 0, 0, 1083, 1084, 1085, 0, 0, 0, + 0, 1086, 0, 1087, 0, 0, 0, 0, 1088, 1089, + 0, 1090, 1091, 116, 1042, 815, 1043, 1044, 1045, 1046, + 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, + 0, 125, 126, 127, 0, 0, 0, 0, 0, 1048, + 0, 0, 128, 129, 130, 0, 131, 132, 133, 134, + 135, 136, 137, 138, 1049, 140, 1050, 1051, 0, 143, + 144, 145, 146, 147, 148, 1052, 785, 149, 150, 151, + 152, 1053, 1054, 155, 0, 156, 157, 158, 159, 786, + 0, 787, 0, 1055, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 0, 172, 173, 174, 175, 176, 177, + 0, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 1056, 190, 191, 1057, 193, 1058, 194, 0, + 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, + 203, 204, 0, 0, 205, 206, 1059, 208, 209, 0, + 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, + 218, 219, 1060, 221, 222, 223, 224, 225, 788, 1061, + 227, 0, 228, 229, 1062, 231, 0, 232, 0, 233, + 234, 0, 235, 236, 237, 238, 239, 240, 0, 241, + 0, 1063, 1064, 244, 245, 0, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 0, 258, + 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, + 268, 269, 270, 271, 272, 1065, 1066, 0, 1067, 0, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 0, 0, 287, 288, 289, 290, 0, 291, 292, + 293, 294, 295, 296, 297, 298, 1068, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 1069, 321, 1070, + 323, 324, 325, 326, 1071, 327, 328, 329, 330, 1072, + 790, 332, 1073, 334, 335, 336, 0, 337, 338, 0, + 0, 1074, 340, 341, 0, 0, 342, 343, 344, 345, + 346, 347, 792, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 0, 0, 0, 0, 360, 361, + 793, 363, 364, 365, 366, 367, 368, 369, 0, 370, + 371, 372, 373, 374, 375, 0, 376, 377, 378, 1075, + 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 0, 397, + 398, 399, 400, 401, 402, 1076, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 0, + 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 0, 426, 427, 428, 1077, 430, 0, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 795, 0, 0, 446, 447, 0, 448, 449, 450, + 451, 452, 453, 454, 0, 455, 1078, 1079, 0, 0, + 458, 459, 796, 461, 797, 1080, 463, 464, 798, 466, + 467, 468, 469, 470, 0, 0, 471, 472, 473, 0, + 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, + 483, 1081, 0, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, + 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, + 508, 509, 510, 511, 512, 513, 514, 515, 1082, 0, + 0, 0, 0, 0, 0, 1083, 2271, 1085, 0, 0, + 0, 0, 1086, 0, 1087, 0, 0, 0, 0, 1088, + 1089, 0, 1090, 1091, 116, 1042, 815, 1043, 1044, 1045, + 1046, 1047, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, + 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, + 1048, 0, 0, 128, 129, 130, 0, 131, 132, 133, + 134, 135, 136, 137, 138, 1049, 140, 1050, 1051, 0, + 143, 144, 145, 146, 147, 148, 1052, 785, 149, 150, + 151, 152, 1053, 1054, 155, 0, 156, 157, 158, 159, + 786, 0, 787, 0, 1055, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 0, 172, 173, 174, 175, 176, + 177, 0, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 1056, 190, 191, 1057, 193, 1058, 194, + 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, + 202, 203, 204, 0, 0, 205, 206, 1059, 208, 209, + 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, + 217, 218, 219, 1060, 221, 222, 223, 224, 225, 788, + 1061, 227, 0, 228, 229, 1062, 231, 0, 232, 0, + 233, 234, 0, 235, 236, 237, 238, 239, 240, 0, + 241, 0, 1063, 1064, 244, 245, 0, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 0, + 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, + 267, 268, 269, 270, 271, 272, 1065, 1066, 0, 1067, + 0, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 0, 0, 287, 288, 289, 290, 0, 291, + 292, 293, 294, 295, 296, 297, 298, 1068, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 1069, 321, + 1070, 323, 324, 325, 326, 1071, 327, 328, 329, 330, + 1072, 790, 332, 1073, 334, 335, 336, 0, 337, 338, + 0, 0, 1074, 340, 341, 0, 0, 342, 343, 344, + 345, 346, 347, 792, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, + 361, 793, 363, 364, 365, 366, 367, 368, 369, 0, + 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, + 1075, 380, 381, 382, 383, 0, 384, 385, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, + 397, 398, 399, 400, 401, 402, 1076, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 0, 426, 427, 428, 1077, 430, 0, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 795, 0, 0, 446, 447, 0, 448, 449, + 450, 451, 452, 453, 454, 0, 455, 1078, 1079, 0, + 0, 458, 459, 796, 461, 797, 1080, 463, 464, 798, + 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, + 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, + 482, 483, 1081, 0, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 1082, + 0, 0, 0, 0, 0, 0, 1083, 1084, 1085, 0, + 0, 0, 0, 1086, 0, 2483, 0, 0, 0, 0, + 1088, 1089, 0, 1090, 1091, 116, 1042, 815, 1043, 1044, + 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, + 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, + 0, 1048, 0, 0, 128, 129, 130, 0, 131, 132, + 133, 134, 135, 136, 137, 138, 1049, 140, 1050, 1051, + 0, 143, 144, 145, 146, 147, 148, 1052, 785, 149, + 150, 151, 152, 1053, 1054, 155, 0, 156, 157, 158, + 159, 786, 0, 787, 0, 1055, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 0, 172, 173, 174, 175, + 176, 177, 0, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 1056, 190, 191, 1057, 193, 1058, + 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, + 201, 202, 203, 204, 0, 0, 205, 206, 1059, 208, + 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, + 216, 217, 218, 219, 1060, 221, 222, 223, 224, 225, + 788, 1061, 227, 0, 228, 229, 1062, 231, 0, 232, + 0, 233, 234, 0, 235, 236, 237, 238, 239, 240, + 0, 241, 0, 1063, 1064, 244, 245, 0, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, + 266, 267, 268, 269, 270, 271, 272, 1065, 1066, 0, + 1067, 0, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 0, 0, 287, 288, 289, 290, 0, + 291, 292, 293, 294, 295, 296, 297, 298, 1068, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 1069, + 321, 1070, 323, 324, 325, 326, 1071, 327, 328, 329, + 330, 1072, 790, 332, 1073, 334, 335, 336, 0, 337, + 338, 0, 0, 1074, 340, 341, 0, 0, 342, 343, + 344, 345, 346, 347, 792, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, + 360, 361, 793, 363, 364, 365, 366, 367, 368, 369, + 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, + 378, 1075, 380, 381, 382, 383, 0, 384, 385, 386, + 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 0, 397, 398, 399, 400, 401, 402, 1076, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, + 424, 425, 0, 426, 427, 428, 1077, 430, 0, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 795, 0, 0, 446, 447, 0, 448, + 449, 450, 451, 452, 453, 454, 0, 455, 1078, 1079, + 0, 0, 458, 459, 796, 461, 797, 1080, 463, 464, + 798, 466, 467, 468, 469, 470, 0, 0, 471, 472, + 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, + 481, 482, 483, 1081, 0, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, + 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, + 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, + 1082, 0, 0, 0, 0, 0, 0, 1083, 3066, 1085, + 0, 0, 0, 0, 1086, 0, 1087, 0, 0, 0, + 0, 1088, 1089, 0, 1090, 1091, 116, 1042, 815, 1043, + 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 1048, 0, 0, 128, 129, 130, 0, 131, + 132, 133, 134, 135, 136, 137, 138, 1049, 140, 1050, + 1051, 0, 143, 144, 145, 146, 147, 148, 1052, 785, + 149, 150, 151, 152, 1053, 1054, 155, 0, 156, 157, + 158, 159, 786, 0, 787, 0, 1055, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 178, 179, 3013, 181, 182, 183, + 184, 185, 186, 187, 188, 1056, 190, 191, 1057, 193, + 1058, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 1059, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 1060, 221, 222, 223, 224, + 225, 788, 1061, 227, 0, 228, 229, 1062, 231, 0, + 232, 0, 233, 234, 0, 235, 236, 237, 238, 239, + 240, 0, 241, 0, 3014, 1064, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 266, 267, 268, 269, 270, 271, 272, 1065, 1066, + 0, 1067, 0, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 288, 289, 290, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 1068, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 1069, 321, 1070, 323, 324, 325, 326, 1071, 327, 328, + 329, 330, 1072, 790, 332, 1073, 334, 335, 336, 0, + 337, 338, 0, 0, 1074, 340, 341, 0, 0, 342, + 343, 344, 345, 346, 347, 792, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 793, 363, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 1075, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 399, 400, 401, 3015, 1076, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 426, 427, 428, 1077, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 795, 0, 0, 446, 447, 0, + 448, 449, 450, 451, 452, 453, 454, 0, 455, 1078, + 1079, 0, 0, 458, 459, 796, 461, 797, 1080, 463, + 464, 798, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 1081, 0, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 1082, 0, 0, 0, 0, 0, 0, 1083, 1084, + 1085, 0, 0, 0, 0, 1086, 0, 3016, 0, 0, + 0, 0, 1088, 1089, 0, 1090, 1091, 116, 1042, 815, + 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, + 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, + 0, 0, 0, 1048, 0, 0, 128, 129, 130, 0, + 131, 132, 133, 134, 135, 136, 137, 3474, 1049, 140, + 1050, 1051, 0, 143, 144, 145, 146, 147, 148, 1052, + 785, 149, 150, 151, 152, 1053, 1054, 155, 0, 156, + 157, 158, 159, 786, 0, 787, 0, 1055, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 0, 172, 173, + 174, 175, 176, 177, 0, 178, 179, 180, 3475, 182, + 183, 184, 185, 186, 187, 188, 1056, 190, 191, 1057, + 193, 1058, 194, 0, 195, 196, 197, 198, 199, 200, + 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, + 1059, 208, 209, 0, 210, 211, 212, 0, 213, 214, + 215, 0, 216, 217, 218, 219, 1060, 221, 222, 223, + 224, 225, 788, 1061, 227, 0, 228, 229, 1062, 231, + 0, 232, 0, 233, 234, 0, 235, 236, 237, 238, + 239, 240, 0, 241, 0, 1063, 1064, 244, 245, 0, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, + 0, 265, 266, 267, 268, 269, 270, 271, 272, 1065, + 1066, 0, 1067, 0, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 0, 0, 287, 288, 289, + 290, 0, 291, 292, 293, 294, 295, 296, 297, 298, + 1068, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, 327, + 328, 329, 330, 1072, 790, 332, 1073, 334, 335, 336, + 0, 337, 338, 0, 0, 1074, 340, 341, 0, 0, + 342, 343, 344, 345, 346, 347, 792, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, + 0, 0, 360, 361, 793, 363, 364, 365, 366, 367, + 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, + 376, 377, 378, 1075, 380, 381, 382, 383, 0, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 0, 397, 398, 399, 400, 401, 402, 1076, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 0, 0, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 0, 426, 427, 428, 1077, 430, + 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 795, 0, 0, 446, 447, + 0, 448, 449, 450, 451, 452, 453, 454, 0, 455, + 1078, 1079, 0, 0, 458, 459, 796, 461, 797, 1080, + 463, 464, 798, 466, 467, 3476, 469, 470, 0, 0, + 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, + 479, 480, 481, 482, 483, 1081, 0, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, + 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, + 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, + 514, 515, 1082, 0, 0, 0, 0, 0, 0, 1083, + 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, 0, + 0, 0, 0, 1088, 1089, 0, 1090, 1091, 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 1242, 0, 1048, 0, 0, 1243, 129, 130, - 0, 131, 132, 133, 1244, 135, 136, 137, 138, 1049, - 1245, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 1246, 0, 1247, 163, - 164, 165, 166, 167, 1248, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 1249, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 1251, 0, 1252, 236, 237, - 1253, 1254, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 1255, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 1256, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 1257, 1258, 279, 1259, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 1260, - 289, 1261, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1262, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 1263, 1070, 323, 324, 325, 326, 1071, - 327, 328, 1264, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 1265, 346, 1266, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 1267, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 1268, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 1269, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 1270, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 1271, 444, 795, 0, 0, 446, - 447, 0, 448, 1272, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 1273, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 1275, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 1686, 125, 126, 127, 0, 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, + 173, 174, 175, 176, 177, 0, 178, 179, 180, 3475, 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, @@ -391098,7 +396726,7 @@ static const yytype_int16 yytable[] = 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, + 1080, 463, 464, 798, 466, 467, 3476, 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, @@ -391106,1354 +396734,1120 @@ static const yytype_int16 yytable[] = 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1701, - 815, 1043, 1044, 1045, 1702, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 1703, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, + 0, 0, 0, 0, 1088, 1089, 0, 1090, 1091, 116, + 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 117, 118, + 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, + 0, 0, 0, 0, 0, 1048, 0, 0, 128, 129, + 130, 0, 131, 132, 133, 134, 135, 136, 137, 138, + 1049, 140, 1050, 1051, 0, 143, 144, 145, 146, 147, + 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, + 0, 156, 157, 158, 159, 786, 0, 787, 0, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 0, + 172, 173, 174, 175, 176, 177, 0, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 1056, 190, + 191, 1057, 193, 0, 194, 0, 195, 196, 197, 198, + 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, + 205, 206, 1059, 208, 209, 0, 210, 211, 212, 0, + 213, 214, 215, 0, 216, 217, 218, 219, 1060, 221, + 222, 223, 224, 225, 788, 1061, 227, 0, 228, 229, + 1062, 231, 0, 232, 0, 233, 234, 0, 235, 236, + 237, 238, 239, 240, 0, 241, 0, 1063, 1064, 244, + 245, 0, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, + 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, + 272, 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 0, 0, 287, + 288, 289, 290, 0, 291, 292, 293, 294, 295, 296, + 297, 298, 1068, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 1069, 321, 1070, 323, 324, 325, 326, + 0, 327, 328, 329, 330, 1072, 790, 332, 1073, 334, + 335, 336, 0, 337, 338, 0, 0, 1074, 340, 341, + 0, 0, 342, 343, 344, 345, 346, 347, 792, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 0, 0, 0, 0, 360, 361, 793, 363, 364, 365, + 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, + 375, 0, 376, 377, 378, 1075, 380, 381, 382, 383, + 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 0, 397, 398, 399, 400, 401, + 402, 1076, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 0, 0, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 0, 426, 427, 428, + 1077, 430, 0, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 795, 0, 0, + 446, 447, 0, 448, 449, 450, 451, 452, 453, 454, + 0, 455, 1078, 1079, 0, 0, 458, 459, 796, 461, + 797, 1080, 463, 464, 798, 466, 467, 468, 469, 470, + 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, + 0, 478, 479, 480, 481, 482, 483, 1081, 0, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 0, 0, + 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 512, 513, 514, 515, 0, 0, 0, 0, 0, 0, + 0, 1409, 1410, 0, 0, 0, 0, 0, 1086, 0, + 1087, 0, 0, 0, 0, 1088, 1089, 0, 1090, 1091, + 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, + 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, + 127, 0, 0, 0, 0, 0, 1048, 0, 0, 128, + 129, 130, 0, 131, 132, 133, 134, 135, 136, 137, + -2044, 1049, 140, 1050, 1051, 0, 143, 144, 145, 146, + 147, 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, + 155, 0, 156, 157, 158, 159, 786, 0, 787, 0, + 1055, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 0, 172, 173, 174, 175, 176, 177, 0, 178, 179, + 180, 3475, 182, 183, 184, 185, 186, 187, 188, 1056, + 190, 191, 1057, 193, 1058, 194, 0, 195, 196, 197, + 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, + 0, 205, 206, 1059, 208, 209, 0, 210, 211, 212, + 0, 213, 214, 215, 0, 216, 217, 218, 219, 1060, + 221, 222, 223, 224, 225, 788, 1061, 227, 0, 228, + 229, 1062, 231, 0, 232, 0, 233, 234, 0, 235, + 236, 237, 238, -2044, 240, 0, 241, 0, 1063, 1064, + 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, + -2044, 254, 255, 256, 257, 0, 258, 259, 260, 261, + 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, + 271, 272, 1065, 1066, 0, 1067, 0, 276, 0, 0, + 279, 280, 281, 282, 283, 284, 285, 286, 0, 0, + 287, 288, 289, -2044, 0, 291, 292, 293, 294, 295, + 296, 297, 298, 1068, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 1069, 321, 1070, 323, 324, 325, + 326, 0, 327, 328, 0, 330, 1072, 790, 332, 1073, + 334, 335, 336, 0, 337, 338, 0, 0, 1074, 340, + 341, 0, 0, 342, 343, 344, 345, 346, 347, 792, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 0, 0, 0, 0, 360, 361, 793, 363, 364, + 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, + 374, 375, 0, 376, 377, 378, 1075, 380, 381, 382, + 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 0, 397, 398, 399, 400, + 401, 402, 1076, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, + 419, 420, 421, 422, 423, 424, 425, 0, -2044, 427, + 428, 1077, 430, 0, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 795, 0, + 0, 446, 447, 0, 448, 449, 450, 451, 452, 453, + 454, 0, 455, 1078, 1079, 0, 0, 458, 459, 796, + 461, 797, 1080, 463, 464, 798, 466, 467, 3476, 469, + 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, + 477, 0, 478, 479, 480, 481, 482, 483, 1081, 0, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 0, + 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, -2044, 0, 0, 0, 0, + 0, 0, 1083, 1084, 1085, 0, 0, 0, 0, 1086, + 0, 1087, 0, 0, 0, 0, 1088, 1089, 0, 1090, + 1091, 116, 1042, 815, 1043, 1044, 0, 1046, 1047, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 1048, 0, 0, + 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, + 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, 145, + 146, 147, 148, 1052, 785, 149, 150, 151, 152, 1053, + 1054, 155, 0, 156, 157, 158, 159, 786, 0, 787, + 0, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 1056, 190, 191, 1057, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 1059, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 1060, 221, 222, 223, 224, 225, 788, 1061, 227, 0, + 228, 229, 1062, 231, 0, 232, 0, 233, 234, 0, + 235, 236, 237, 238, 239, 240, 0, 241, 0, 1063, + 1064, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, + 270, 271, 272, 1065, 1066, 0, 1067, 0, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 288, 289, 290, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 1068, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 1069, 321, 1070, 323, 324, + 325, 326, 0, 327, 328, 329, 330, 1072, 790, 332, + 1073, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 345, 346, 347, + 792, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 793, 363, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 1075, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 399, + 400, 401, 402, 2174, 2175, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 426, + 427, 428, 1077, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 795, + 0, 0, 446, 447, 0, 448, 449, 450, 451, 452, + 453, 454, 0, 455, 1078, 1079, 0, 0, 458, 459, + 796, 461, 797, 1080, 463, 464, 798, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 1081, + 0, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 0, 0, 0, 0, + 0, 0, 0, 2176, 2177, 0, 0, 0, 0, 0, + 1086, 0, 1087, 0, 0, 0, 0, 1088, 1089, 0, + 1090, 1091, 116, 1042, 815, 1043, 1044, 1045, 1046, 1047, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, + 125, 126, 127, 0, 0, 0, 0, 0, 1048, 0, + 0, 128, 129, 130, 0, 131, 132, 133, 134, 135, + 136, 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, + 145, 146, 147, 148, 1052, 785, 149, 150, 151, 152, + 1053, 1054, 155, 0, 156, 157, 158, 159, 786, 0, + 787, 0, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 1056, 190, 191, 1057, 193, 0, 194, 0, 195, + 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, + 204, 0, 0, 205, 206, 1059, 208, 209, 0, 210, + 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, + 219, 1060, 221, 222, 223, 224, 225, 788, 1061, 227, + 0, 228, 229, 1062, 231, 0, 232, 0, 233, 234, + 0, 235, 236, 237, 238, 239, 240, 0, 241, 0, + 1063, 1064, 244, 245, 0, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 0, 258, 259, + 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, + 269, 270, 271, 272, 1065, 1066, 0, 1067, 0, 276, + 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 0, 0, 287, 288, 289, 290, 0, 291, 292, 293, + 294, 295, 296, 297, 298, 1068, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 1069, 321, 1070, 323, + 324, 325, 326, 0, 327, 328, 329, 330, 1072, 790, + 332, 1073, 334, 335, 336, 0, 337, 338, 0, 0, + 1074, 340, 341, 0, 0, 342, 343, 344, 345, 346, + 347, 792, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 0, 0, 0, 0, 360, 361, 793, + 363, 364, 365, 366, 367, 368, 369, 0, 370, 371, + 372, 373, 374, 375, 0, 376, 377, 378, 1075, 380, + 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, + 399, 400, 401, 402, 1076, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, + 426, 427, 428, 1077, 430, 0, 431, 432, 433, 434, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 795, 0, 0, 446, 447, 0, 448, 449, 450, 451, + 452, 453, 454, 0, 455, 1078, 1079, 0, 0, 458, + 459, 796, 461, 797, 1080, 463, 464, 798, 466, 467, + 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, + 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, + 1081, 0, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 0, 0, 0, + 0, 0, 0, 0, 1409, 1410, 0, 0, 0, 0, + 0, 1086, 0, 1087, 0, 0, 0, 0, 1088, 1089, + 0, 1090, 1091, 116, 1042, 815, 1043, 1044, 0, 1046, + 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, + 0, 125, 126, 127, 0, 0, 0, 0, 0, 1048, + 0, 0, 128, 129, 130, 0, 131, 132, 133, 134, + 135, 136, 137, 138, 1049, 140, 1050, 1051, 0, 143, + 144, 145, 146, 147, 148, 1052, 785, 149, 150, 151, + 152, 1053, 1054, 155, 0, 156, 157, 158, 159, 786, + 0, 787, 0, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 0, 172, 173, 174, 175, 176, 177, + 0, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 1056, 190, 191, 1057, 193, 0, 194, 0, + 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, + 203, 204, 0, 0, 205, 206, 1059, 208, 209, 0, + 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, + 218, 219, 1060, 221, 222, 223, 224, 225, 788, 1061, + 227, 0, 228, 229, 1062, 231, 0, 232, 0, 233, + 234, 0, 235, 236, 237, 238, 239, 240, 0, 241, + 3033, 1063, 1064, 244, 245, 0, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, -717, 258, + 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, + 268, 269, 270, 271, 272, 1065, 1066, 0, 1067, 0, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 0, 0, 287, 288, 289, 290, 0, 291, 292, + 293, 294, 295, 296, 297, 298, 1068, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 1069, 321, 1070, + 323, 324, 325, 326, 0, 327, 328, 329, 330, 1072, + 790, 332, 1073, 334, 335, 336, 0, 337, 338, 0, + 0, 339, 340, 341, 0, 0, 342, 343, 344, 345, + 346, 347, 792, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 0, 0, 0, 0, 360, 361, + 793, 363, 364, 365, 366, 367, 368, 369, 0, 370, + 371, 372, 373, 374, 375, 0, 376, 377, 378, 1075, + 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 0, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 0, + 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 0, 426, 427, 428, 1077, 430, 0, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 795, 0, 0, 446, 447, 0, 448, 449, 450, + 451, 452, 453, 454, 0, 455, 1078, 1079, 0, 0, + 458, 459, 796, 461, 797, 1080, 463, 464, 798, 466, + 467, 468, 469, 470, 0, 0, 471, 472, 473, 0, + 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, + 483, 1081, 0, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, + 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, + 508, 509, 510, 511, 512, 513, 514, 515, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1086, 0, 2726, 0, 0, 0, 0, 1088, + 1089, 0, 1090, 1091, 116, 1042, 815, 1043, 1044, 0, + 1046, 1047, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, + 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, + 1048, 0, 0, 128, 129, 130, 0, 131, 132, 133, + 134, 135, 136, 137, 138, 1049, 140, 1050, 1051, 0, + 143, 144, 145, 146, 147, 148, 1052, 785, 149, 150, + 151, 152, 1053, 1054, 155, 0, 156, 157, 158, 159, + 786, 0, 787, 0, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 0, 172, 173, 174, 175, 176, + 177, 0, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 1056, 190, 191, 1057, 193, 0, 194, + 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, + 202, 203, 204, 0, 0, 205, 206, 1059, 208, 209, + 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, + 217, 218, 219, 1060, 221, 222, 223, 224, 225, 788, + 1061, 227, 0, 228, 229, 1062, 231, 0, 232, 0, + 233, 234, 0, 235, 236, 237, 238, 239, 240, 0, + 241, 0, 1063, 1064, 244, 245, 0, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 0, + 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, + 267, 268, 269, 270, 271, 272, 1065, 1066, 0, 1067, + 0, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 0, 0, 287, 288, 289, 290, 0, 291, + 292, 293, 294, 295, 296, 297, 298, 1068, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 1069, 321, + 1070, 323, 324, 325, 326, 0, 327, 328, 329, 330, + 1072, 790, 332, 1073, 334, 335, 336, 0, 337, 338, + 0, 0, 339, 340, 341, 0, 0, 342, 343, 344, + 345, 346, 347, 792, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, + 361, 793, 363, 364, 365, 366, 367, 368, 369, 0, + 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, + 1075, 380, 381, 382, 383, 0, 384, 385, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 0, 426, 427, 428, 1077, 430, 0, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 795, 0, 0, 446, 447, 0, 448, 449, + 450, 451, 452, 453, 454, 0, 455, 1078, 1079, 0, + 0, 458, 459, 796, 461, 797, 1080, 463, 464, 798, + 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, + 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, + 482, 483, 1081, 0, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1086, 0, 2726, 0, 0, 0, 0, + 1088, 1089, 0, 1090, 1091, 116, 1042, 815, 1043, 1044, + 0, 1046, 1047, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, + 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, + 0, 1048, 0, 0, 128, 129, 130, 0, 131, 132, + 133, 134, 135, 136, 137, 138, 1049, 140, 1050, 1051, + 0, 143, 144, 145, 146, 147, 148, 1052, 785, 149, + 150, 151, 152, 1053, 1054, 155, 0, 156, 157, 158, + 159, 786, 0, 787, 0, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 0, 172, 173, 174, 175, + 176, 177, 0, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 1056, 190, 191, 1057, 193, 0, + 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, + 201, 202, 203, 204, 0, 0, 205, 206, 1059, 208, + 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, + 216, 217, 218, 219, 1060, 221, 222, 223, 224, 225, + 788, 1061, 227, 0, 228, 229, 1062, 231, 0, 232, + 0, 233, 234, 0, 235, 236, 237, 238, 239, 240, + 0, 241, 0, 1063, 1064, 244, 245, 0, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, + 266, 267, 268, 269, 270, 271, 272, 1065, 1066, 0, + 1067, 0, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 0, 0, 287, 288, 289, 290, 0, + 291, 292, 293, 294, 295, 296, 297, 298, 1068, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 1069, + 321, 1070, 323, 324, 325, 326, 0, 327, 328, 329, + 330, 1072, 790, 332, 1073, 334, 335, 336, 0, 337, + 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, + 344, 345, 346, 347, 792, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, + 360, 361, 793, 363, 364, 365, 366, 367, 368, 369, + 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, + 378, 1075, 380, 381, 382, 383, 0, 384, 385, 386, + 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 0, 397, 398, 399, 400, 401, 402, 1076, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, + 424, 425, 0, 426, 427, 428, 1077, 430, 0, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 795, 0, 0, 446, 447, 0, 448, + 449, 450, 451, 452, 453, 454, 0, 455, 1078, 1079, + 0, 0, 458, 459, 796, 461, 797, 1080, 463, 464, + 798, 466, 467, 468, 469, 470, 0, 0, 471, 472, + 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, + 481, 482, 483, 1081, 0, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, + 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, + 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1086, 0, 1087, 0, 0, 0, + 0, 1088, 1089, 0, 1090, 1091, 116, 1042, 815, 1043, + 1044, 1045, 1046, 1047, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 1048, 0, 0, 128, 129, 130, 0, 131, + 132, 133, 134, 135, 136, 137, 0, 1049, 140, 1050, + 1051, 0, 143, 144, 145, 146, 147, 148, 1052, 785, + 149, 150, 151, 152, 1053, 1054, 155, 0, 156, 157, + 158, 159, 786, 0, 787, 0, 1055, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 1056, 190, 191, 1057, 193, + 1058, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 1059, + 208, 209, 0, 210, 211, 212, 0, 213, 0, 215, + 0, 216, 217, 218, 219, 1060, 221, 222, 223, 224, + 225, 788, 1061, 227, 0, 228, 229, 1062, 231, 0, + 232, 0, 233, 234, 0, 235, 236, 237, 238, 0, + 240, 0, 241, 0, 1063, 1064, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 266, 267, 268, 269, 270, 271, 272, 1065, 1066, + 0, 1067, 0, 276, 0, 0, 279, 280, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 288, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 1068, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 1069, 321, 1070, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 1072, 790, 332, 1073, 334, 335, 336, 0, + 337, 338, 0, 0, 1074, 340, 341, 0, 0, 342, + 343, 344, 345, 346, 347, 792, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 793, 363, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 1075, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 399, 400, 401, 402, 1076, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 1077, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 795, 0, 0, 446, 447, 0, + 448, 449, 450, 451, 452, 453, 454, 0, 455, 1078, + 1079, 0, 0, 458, 459, 796, 461, 797, 1080, 463, + 464, 798, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 1081, 0, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 0, 0, 0, 0, 0, 0, 0, 1083, 1084, + 1085, 0, 964, 1340, 815, 1086, 0, 1087, 1046, 0, + 0, 0, 1088, 1089, 0, 1090, 1091, 0, 0, 0, + 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, + 125, 126, 127, 0, 0, 0, 560, 0, 0, 0, + 0, 565, 129, 130, 0, 131, 132, 133, 567, 135, + 136, 137, 568, 569, 570, 571, 572, 0, 143, 144, + 145, 146, 147, 148, 0, 0, 149, 150, 151, 152, + 576, 577, 155, 0, 156, 157, 158, 159, 579, 0, + 581, 0, 583, 163, 164, 165, 166, 167, 584, 169, + 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, + 587, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 589, 190, 191, 590, 193, 0, 194, 0, 195, + 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, + 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, + 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, + 219, 600, 221, 222, 223, 224, 225, 601, 1341, 227, + 0, 228, 229, 604, 231, 0, 232, 0, 233, 607, + 0, 609, 236, 237, 610, 611, 240, 0, 241, 0, + 614, 615, 244, 245, 0, 246, 247, 248, 249, 250, + 251, 252, 617, 254, 255, 256, 257, 0, 258, 259, + 260, 261, 262, 263, 264, 0, 265, 620, 621, 268, + 269, 270, 271, 272, 622, 623, 0, 625, 0, 276, + 627, 628, 279, 629, 281, 282, 283, 284, 285, 286, + 0, 0, 287, 632, 289, 633, 0, 291, 292, 293, + 294, 295, 296, 297, 298, 635, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 636, 637, 638, 323, + 324, 325, 639, 0, 327, 328, 641, 330, 0, 643, + 332, 644, 334, 335, 336, 0, 337, 338, 1342, 0, + 339, 340, 341, 0, 0, 342, 343, 650, 651, 346, + 652, 653, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 0, 0, 0, 0, 360, 361, 658, + 659, 364, 365, 660, 367, 368, 369, 0, 370, 371, + 372, 373, 374, 375, 0, 376, 377, 378, 663, 380, + 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, + 666, 400, 401, 402, 667, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 0, 669, + 417, 418, 419, 420, 421, 422, 670, 424, 425, 0, + 672, 427, 428, 673, 430, 0, 431, 432, 433, 434, + 435, 436, 437, 438, 439, 440, 441, 442, 675, 444, + 676, 0, 0, 446, 447, 0, 448, 680, 450, 451, + 452, 453, 454, 0, 455, 682, 683, 0, 0, 458, + 459, 686, 461, 687, 1343, 463, 464, 689, 466, 467, + 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, + 475, 476, 477, 0, 478, 479, 480, 481, 482, 694, + 695, 0, 485, 697, 487, 488, 489, 490, 491, 492, + 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, + 499, 500, 702, 703, 704, 705, 706, 707, 708, 709, + 710, 711, 712, 512, 513, 514, 515, 0, 0, 0, + 0, 523, 0, 0, 1344, 1345, 2349, 0, 0, 0, + 0, 0, 0, 2350, 0, 0, 0, 0, 0, 1089, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 1000, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, -524, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, -524, + 228, 229, 230, 231, -524, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, -524, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, -524, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, -524, 337, 338, 0, 0, 339, + 340, 341, 0, -524, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, -524, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1158, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 964, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2436, 3217, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 3, 4, 0, 560, 0, 0, 0, 0, + 565, 129, 130, 0, 131, 132, 133, 567, 135, 136, + 137, 568, 569, 570, 571, 572, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 576, + 577, 155, 0, 156, 157, 158, 159, 579, 0, 581, + 0, 583, 163, 164, 165, 166, 167, 584, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 587, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 589, 190, 191, 590, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 14, 15, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 600, 221, 222, 223, 224, 225, 601, 0, 227, 0, + 228, 229, 604, 231, 0, 232, 0, 233, 607, 23, + 609, 236, 237, 610, 611, 240, 0, 241, 0, 614, + 615, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 617, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 620, 621, 268, 269, + 270, 271, 272, 622, 623, 0, 625, 0, 276, 627, + 628, 279, 629, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 632, 289, 633, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 635, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 636, 637, 638, 323, 324, + 325, 639, 0, 327, 328, 641, 330, 0, 643, 332, + 644, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 650, 651, 346, 652, + 653, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 27, 28, 29, 0, 360, 361, 658, 659, + 364, 365, 660, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 663, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 666, + 400, 401, 402, 667, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 34, 669, 417, + 418, 419, 420, 421, 422, 670, 424, 425, 36, 672, + 427, 428, 673, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 675, 444, 676, + 38, 0, 446, 447, 39, 448, 680, 450, 451, 452, + 453, 454, 0, 455, 682, 683, 0, 0, 458, 459, + 686, 461, 687, 0, 463, 464, 689, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 41, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 965, 695, + 0, 485, 697, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 45, 495, 496, 497, 498, 499, + 500, 702, 703, 704, 705, 706, 707, 708, 709, 710, + 711, 712, 512, 513, 514, 515, 0, 116, 46, 549, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 47, 0, 0, 0, 117, 118, 119, 120, + 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, + 0, 0, 0, 0, 0, 0, 128, 129, 130, 0, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 0, 143, 144, 145, 146, 147, 148, 0, + 785, 149, 150, 151, 152, 153, 154, 155, 0, 156, + 157, 158, 159, 786, 0, 787, 0, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 0, 172, 173, + 174, 175, 176, 177, 0, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, + 14, 15, 201, 202, 203, 204, 0, 0, 205, 206, + 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, + 215, 0, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 788, 0, 227, 0, 228, 229, 230, 231, + 0, 232, 0, 233, 234, 23, 235, 236, 237, 238, + 239, 240, 0, 241, 0, 242, 243, 244, 245, 0, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, + 0, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 0, 275, 0, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 789, 0, 287, 288, 289, + 290, 0, 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, 0, 327, + 328, 329, 330, 0, 790, 332, 333, 334, 335, 336, + 0, 337, 338, 0, 791, 339, 340, 341, 0, 0, + 342, 343, 344, 345, 346, 347, 792, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 27, 28, + 29, 0, 360, 361, 793, 363, 364, 365, 366, 367, + 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, + 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 0, 397, 398, 399, 400, 401, 402, 403, + 794, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 34, 0, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 36, 426, 427, 428, 429, 430, + 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 795, 38, 0, 446, 447, + 39, 448, 449, 450, 451, 452, 453, 454, 0, 455, + 456, 457, 0, 0, 458, 459, 796, 461, 797, 0, + 463, 464, 798, 466, 467, 468, 469, 470, 0, 0, + 471, 472, 473, 41, 474, 475, 476, 477, 0, 478, + 479, 480, 481, 482, 799, 484, 0, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, + 45, 495, 496, 497, 498, 499, 500, 501, 502, 503, + 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, + 514, 515, 0, 116, 46, 549, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 800, 0, + 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, + 0, 125, 126, 127, 0, 0, 0, 0, 0, 0, + 0, 0, 128, 129, 130, 0, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 0, 143, + 144, 145, 146, 147, 148, 0, 785, 149, 150, 151, + 152, 153, 154, 155, 0, 156, 157, 158, 159, 786, + 0, 787, 0, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 0, 172, 173, 174, 175, 176, 177, + 0, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 0, 194, 0, + 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, + 203, 204, 0, 0, 205, 206, 207, 208, 209, 0, + 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 788, 0, + 227, 0, 228, 229, 230, 231, 0, 232, 0, 233, + 234, 0, 235, 236, 237, 238, 239, 240, 0, 241, + 0, 242, 243, 244, 245, 0, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 0, 258, + 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 0, 275, 0, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 789, 0, 287, 288, 289, 290, 0, 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, 0, 327, 328, 329, 330, 0, + 790, 332, 333, 334, 335, 336, 0, 337, 338, 0, + 791, 339, 340, 341, 0, 0, 342, 343, 344, 345, + 346, 347, 792, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 0, 0, 0, 0, 360, 361, + 793, 363, 364, 365, 366, 367, 368, 369, 0, 370, + 371, 372, 373, 374, 375, 0, 376, 377, 378, 379, + 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 0, 397, + 398, 399, 400, 401, 402, 403, 794, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 0, + 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 0, 426, 427, 428, 429, 430, 0, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 795, 0, 0, 446, 447, 0, 448, 449, 450, + 451, 452, 453, 454, 0, 455, 456, 457, 0, 0, + 458, 459, 796, 461, 797, 0, 463, 464, 798, 466, + 467, 468, 469, 470, 0, 0, 471, 472, 473, 0, + 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, + 799, 484, 0, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, + 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, + 508, 509, 510, 511, 512, 513, 514, 515, 116, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 800, 0, 0, 117, 118, 119, + 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, + 0, 0, 0, 0, 0, 0, 0, 128, 129, 130, + 0, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 0, 143, 144, 145, 146, 147, 148, + 0, 785, 149, 150, 151, 152, 153, 154, 155, 0, + 156, 157, 158, 159, 786, 0, 787, 0, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, + 206, 207, 208, 209, 0, 210, 211, 212, 0, 213, + 214, 215, 0, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 788, 0, 227, 0, 228, 229, 230, 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, + 238, 239, 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, + 273, 274, 0, 275, 0, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 0, + 327, 328, 329, 330, 0, 790, 332, 333, 334, 335, + 336, 0, 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, + 0, 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 403, 794, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, + 421, 422, 423, 424, 425, 0, 426, 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, + 455, 456, 457, 0, 0, 458, 459, 796, 461, 797, + 0, 463, 464, 798, 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, + 478, 479, 480, 481, 482, 483, 484, 0, 485, 486, 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, + 513, 514, 515, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 47, + 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, + 0, 125, 126, 127, 0, 0, 0, 0, 0, 0, + 0, 0, 128, 129, 130, 0, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 0, 143, + 144, 145, 146, 147, 148, 0, 785, 149, 150, 151, + 152, 153, 154, 155, 0, 156, 157, 158, 159, 786, + 0, 787, 0, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 0, 172, 173, 174, 175, 176, 177, + 0, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 0, 194, 0, + 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, + 203, 204, 0, 0, 205, 206, 207, 208, 209, 0, + 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 788, 0, + 227, 0, 228, 229, 230, 231, 0, 232, 0, 233, + 234, 0, 235, 236, 237, 238, 239, 240, 0, 241, + 0, 242, 243, 244, 245, 0, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 0, 258, + 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 0, 275, 0, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 0, 0, 287, 288, 289, 290, 0, 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, 0, 327, 328, 329, 330, 0, + 790, 332, 333, 334, 335, 336, 0, 337, 338, 0, + 0, 339, 340, 341, 0, 0, 342, 343, 344, 345, + 346, 347, 792, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 0, 0, 0, 0, 360, 361, + 793, 363, 364, 365, 366, 367, 368, 369, 0, 370, + 371, 372, 373, 374, 375, 0, 376, 377, 378, 379, + 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 0, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 0, + 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 0, 426, 427, 428, 429, 430, 0, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 795, 0, 0, 446, 447, 0, 448, 449, 450, + 451, 452, 453, 454, 0, 455, 456, 457, 0, 0, + 458, 459, 796, 461, 797, 0, 463, 464, 798, 466, + 467, 468, 469, 470, 0, 0, 471, 472, 473, 0, + 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, + 483, 484, 0, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, + 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, + 508, 509, 510, 511, 512, 513, 514, 515, 523, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3305, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 1422, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 0, 0, 0, 0, 0, 0, 0, 0, 129, 130, + 0, 131, 132, 133, 0, 135, 136, 137, 138, 139, + 0, 141, 142, 0, 143, 144, 145, 146, 147, 148, + 0, 0, 149, 150, 151, 152, 153, 154, 155, 0, + 156, 157, 158, 159, 160, 0, 0, 0, 162, 163, + 164, 165, 166, 167, 0, 169, 170, 171, 0, 172, + 173, 174, 175, 176, 177, 0, 0, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 0, 194, 0, 195, 196, 197, 198, 199, + 200, 14, 15, 201, 202, 203, 204, 0, 0, 205, + 206, 207, 208, 209, 0, 210, 211, 212, 0, 213, + 214, 215, 0, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 0, 227, 0, 228, 229, 230, + 231, 0, 232, 0, 233, 0, 23, 0, 236, 237, + 524, 0, 240, 0, 241, 0, 242, 243, 244, 245, + 0, 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, + 264, 0, 265, 0, 267, 268, 269, 270, 271, 272, + 273, 274, 0, 275, 0, 276, 0, 0, 279, 0, + 281, 282, 283, 284, 285, 286, 0, 0, 287, 0, + 289, 0, 0, 291, 292, 293, 294, 295, 296, 297, + 298, 525, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, + 318, 319, 320, 0, 322, 323, 324, 325, 326, 0, + 327, 328, 0, 330, 0, 331, 332, 333, 334, 335, + 336, 0, 337, 338, 0, 0, 339, 340, 341, 0, + 0, 342, 343, 344, 0, 346, 0, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 27, + 28, 29, 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, + 0, 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, + 394, 395, 396, 0, 397, 398, 0, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 34, 0, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 36, 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, + 439, 440, 441, 442, 526, 444, 445, 38, 0, 446, + 447, 39, 448, 0, 450, 451, 452, 453, 454, 0, + 455, 456, 457, 0, 0, 458, 459, 460, 461, 462, + 0, 463, 464, 465, 466, 467, 468, 469, 470, 0, + 0, 471, 472, 473, 41, 474, 475, 476, 477, 0, + 478, 479, 480, 481, 482, 799, 484, 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, + 0, 45, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, + 513, 514, 515, 523, 0, 46, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 47, + 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, + 886, 125, 126, 127, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 129, 130, 0, 131, 132, 133, 0, + 135, 136, 137, 138, 139, 0, 141, 142, 0, 143, + 144, 145, 146, 147, 148, 0, 0, 149, 150, 151, + 152, 153, 154, 155, 0, 156, 157, 158, 159, 160, + 0, 0, 0, 162, 163, 164, 165, 166, 167, 0, + 169, 170, 171, 0, 172, 173, 174, 175, 176, 177, + 0, 0, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 0, 194, 0, + 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, + 203, 204, 0, 0, 205, 206, 207, 208, 209, 0, + 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 0, + 227, 0, 228, 229, 230, 231, 0, 232, 0, 233, + 0, 23, 0, 236, 237, 524, 0, 240, 0, 241, + 0, 242, 243, 244, 245, 0, 246, 247, 248, 249, + 250, 251, 252, 0, 254, 255, 256, 257, 0, 258, + 259, 260, 261, 262, 263, 264, 0, 265, 0, 267, + 268, 269, 270, 271, 272, 273, 274, 0, 275, 0, + 276, 0, 0, 279, 0, 281, 282, 283, 284, 285, + 286, 0, 0, 287, 0, 289, 0, 0, 291, 292, + 293, 294, 295, 296, 297, 298, 525, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 0, 322, + 323, 324, 325, 326, 0, 327, 328, 0, 330, 0, + 331, 332, 333, 334, 335, 336, 0, 337, 338, 0, + 0, 339, 340, 341, 0, 0, 342, 343, 344, 0, + 346, 0, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 27, 28, 29, 0, 360, 361, + 362, 0, 364, 365, 366, 367, 368, 369, 0, 370, + 371, 372, 373, 374, 375, 0, 376, 377, 378, 379, + 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 0, 397, + 398, 0, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 34, + 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 0, 0, 427, 428, 429, 430, 0, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 526, + 444, 445, 0, 0, 446, 447, 39, 448, 0, 450, + 451, 452, 453, 454, 0, 455, 887, 457, 0, 0, + 888, 459, 460, 461, 462, 0, 463, 464, 465, 466, + 467, 468, 469, 470, 0, 0, 471, 472, 473, 41, + 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, + 799, 484, 0, 485, 0, 487, 488, 489, 490, 491, + 492, 493, 0, 0, 494, 0, 45, 495, 496, 497, + 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, + 508, 509, 510, 511, 512, 513, 514, 515, 523, 0, + 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 47, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, + 0, 0, 0, 0, 0, 0, 0, 0, 129, 130, + 0, 131, 132, 133, 0, 135, 136, 137, 138, 139, + 0, 141, 142, 0, 143, 144, 145, 146, 147, 148, + 0, 0, 149, 150, 151, 152, 153, 154, 155, 0, + 156, 157, 158, 159, 160, 0, 0, 0, 162, 163, + 164, 165, 166, 167, 0, 169, 170, 171, 0, 172, + 173, 174, 175, 176, 177, 0, 0, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 206, 207, 208, 209, 0, 210, 211, 212, 0, 213, + 214, 215, 0, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 0, 227, 0, 228, 229, 230, + 231, 0, 232, 0, 233, 0, 23, 0, 236, 237, + 524, 0, 240, 0, 241, 0, 242, 243, 244, 245, + 0, 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, + 264, 0, 265, 0, 267, 268, 269, 270, 271, 272, + 273, 274, 0, 275, 0, 276, 0, 0, 279, 0, + 281, 282, 283, 284, 285, 286, 0, 0, 287, 0, + 289, 0, 0, 291, 292, 293, 294, 295, 296, 297, + 298, 525, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, + 318, 319, 320, 0, 322, 323, 324, 325, 326, 0, + 327, 328, 0, 330, 0, 331, 332, 333, 334, 335, + 336, 0, 337, 338, 0, 0, 339, 340, 341, 0, + 0, 342, 343, 344, 0, 346, 0, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 27, + 28, 29, 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, + 0, 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, + 394, 395, 396, 0, 397, 398, 0, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 34, 0, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, + 439, 440, 441, 442, 526, 444, 445, 0, 0, 446, + 447, 39, 448, 0, 450, 451, 452, 453, 454, 0, + 455, 456, 457, 0, 0, 458, 459, 460, 461, 462, + 0, 463, 464, 465, 466, 467, 468, 469, 470, 0, + 0, 471, 472, 473, 41, 474, 475, 476, 477, 0, + 478, 479, 480, 481, 482, 799, 484, 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, + 0, 45, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 2046, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 2669, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 2790, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 3005, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 3006, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 3007, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 3008, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 3009, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 3157, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 3296, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1706, 1707, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 2183, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 2266, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 2476, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 3060, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 3006, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 3007, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 3008, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 3009, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 3472, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 3473, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 3474, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 3473, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 1071, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 3474, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 1082, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 0, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 0, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 0, 0, 0, 0, 0, 0, 0, - 1408, 1409, 0, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, -2041, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 1055, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 3473, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 1058, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, -2041, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, -2041, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 0, 0, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, -2041, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 0, - 327, 328, 0, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, -2041, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 3474, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, -2041, 0, 0, 0, 0, 0, 0, - 1083, 1084, 1085, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 0, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 0, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 0, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 339, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 2169, 2170, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 0, 0, 0, 0, 0, 0, 0, - 2171, 2172, 0, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 1045, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 0, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 0, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 0, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 1074, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 0, 0, 0, 0, 0, 0, 0, - 1408, 1409, 0, 0, 0, 0, 0, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 116, 1042, - 815, 1043, 1044, 0, 1046, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, - 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, - 0, 0, 0, 0, 1048, 0, 0, 128, 129, 130, - 0, 131, 132, 133, 134, 135, 136, 137, 138, 1049, - 140, 1050, 1051, 0, 143, 144, 145, 146, 147, 148, - 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, 0, - 156, 157, 158, 159, 786, 0, 787, 0, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1056, 190, 191, - 1057, 193, 0, 194, 0, 195, 196, 197, 198, 199, - 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, - 206, 1059, 208, 209, 0, 210, 211, 212, 0, 213, - 214, 215, 0, 216, 217, 218, 219, 1060, 221, 222, - 223, 224, 225, 788, 1061, 227, 0, 228, 229, 1062, - 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, - 238, 239, 240, 0, 241, 0, 1063, 1064, 244, 245, - 0, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 272, - 1065, 1066, 0, 1067, 0, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 0, 0, 287, 288, - 289, 290, 0, 291, 292, 293, 294, 295, 296, 297, - 298, 1068, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1069, 321, 1070, 323, 324, 325, 326, 0, - 327, 328, 329, 330, 1072, 790, 332, 1073, 334, 335, - 336, 0, 337, 338, 0, 0, 339, 340, 341, 0, - 0, 342, 343, 344, 345, 346, 347, 792, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, - 0, 0, 0, 360, 361, 793, 363, 364, 365, 366, - 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, - 0, 376, 377, 378, 1075, 380, 381, 382, 383, 0, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 398, 399, 400, 401, 402, - 1076, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 0, 426, 427, 428, 1077, - 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 795, 0, 0, 446, - 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, - 455, 1078, 1079, 0, 0, 458, 459, 796, 461, 797, - 1080, 463, 464, 798, 466, 467, 468, 469, 470, 0, - 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 1081, 0, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, - 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 0, 0, 0, 0, 0, 0, 116, - 1042, 815, 1043, 1044, 1045, 1046, 1047, 1086, 0, 1087, - 0, 0, 0, 0, 1088, 1089, 1090, 1091, 117, 118, + 513, 514, 515, 0, 523, 46, 549, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 47, + 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, + 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 129, 130, 0, 131, 132, 133, + 0, 135, 136, 137, 138, 139, 0, 141, 142, 0, + 143, 144, 145, 146, 147, 148, 0, 0, 149, 150, + 151, 152, 153, 154, 155, 0, 156, 157, 158, 159, + 160, 0, 0, 0, 162, 163, 164, 165, 166, 167, + 0, 169, 170, 171, 0, 172, 173, 174, 175, 176, + 177, 0, 0, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 0, 194, + 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, + 202, 203, 204, 0, 0, 205, 206, 207, 208, 209, + 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 0, 227, 0, 228, 229, 230, 231, 0, 232, 0, + 233, 0, 0, 0, 236, 237, 524, 0, 240, 0, + 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, + 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, + 258, 259, 260, 261, 262, 263, 264, 0, 265, 0, + 267, 268, 269, 270, 271, 272, 273, 274, 0, 275, + 0, 276, 0, 0, 279, 0, 281, 282, 283, 284, + 285, 286, 0, 0, 287, 0, 289, 0, 0, 291, + 292, 293, 294, 295, 296, 297, 298, 525, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 0, + 322, 323, 324, 325, 326, 0, 327, 328, 0, 330, + 0, 331, 332, 333, 334, 335, 336, 0, 337, 338, + 0, 0, 339, 340, 341, 0, 0, 342, 343, 344, + 0, 346, 0, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, + 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, + 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, + 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, + 397, 398, 0, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 0, 0, 427, 428, 429, 430, 0, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 526, 444, 445, 0, 0, 446, 447, 0, 448, 0, + 450, 451, 452, 453, 454, 0, 455, 456, 457, 0, + 0, 458, 459, 460, 461, 462, 0, 463, 464, 465, + 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, + 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, + 482, 483, 484, 0, 485, 0, 487, 488, 489, 490, + 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 523, + 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 985, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, - 0, 0, 0, 0, 0, 1048, 0, 0, 128, 129, - 130, 0, 131, 132, 133, 134, 135, 136, 137, 0, - 1049, 140, 1050, 1051, 0, 143, 144, 145, 146, 147, - 148, 1052, 785, 149, 150, 151, 152, 1053, 1054, 155, - 0, 156, 157, 158, 159, 786, 0, 787, 0, 1055, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 0, - 172, 173, 174, 175, 176, 177, 0, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 1056, 190, - 191, 1057, 193, 1058, 194, 0, 195, 196, 197, 198, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 129, + 130, 0, 131, 132, 133, 0, 135, 136, 137, 138, + 139, 0, 141, 142, 0, 143, 144, 145, 146, 147, + 148, 0, 0, 149, 150, 151, 152, 153, 154, 155, + 0, 156, 157, 158, 159, 160, 0, 0, 0, 162, + 163, 164, 165, 166, 167, 0, 169, 170, 171, 0, + 172, 173, 174, 175, 176, 177, 0, 0, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, - 205, 206, 1059, 208, 209, 0, 210, 211, 212, 0, - 213, 0, 215, 0, 216, 217, 218, 219, 1060, 221, - 222, 223, 224, 225, 788, 1061, 227, 0, 228, 229, - 1062, 231, 0, 232, 0, 233, 234, 0, 235, 236, - 237, 238, 0, 240, 0, 241, 0, 1063, 1064, 244, + 205, 206, 207, 208, 209, 0, 210, 211, 212, 0, + 213, 214, 215, 0, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 0, 227, 0, 228, 229, + 230, 231, 0, 232, 0, 233, 0, 0, 0, 236, + 237, 524, 0, 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, - 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, - 272, 1065, 1066, 0, 1067, 0, 276, 0, 0, 279, - 280, 281, 282, 283, 284, 285, 286, 0, 0, 287, - 288, 289, 0, 0, 291, 292, 293, 294, 295, 296, - 297, 298, 1068, 300, 301, 302, 303, 304, 305, 306, + 263, 264, 0, 265, 0, 267, 268, 269, 270, 271, + 272, 273, 274, 0, 275, 0, 276, 0, 0, 279, + 0, 281, 282, 283, 284, 285, 286, 0, 0, 287, + 0, 289, 0, 0, 291, 292, 293, 294, 295, 296, + 297, 298, 525, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 1069, 321, 1070, 323, 324, 325, 326, - 0, 327, 328, 0, 330, 1072, 790, 332, 1073, 334, - 335, 336, 0, 337, 338, 0, 0, 1074, 340, 341, - 0, 0, 342, 343, 344, 345, 346, 347, 792, 349, + 317, 318, 319, 320, 0, 322, 323, 324, 325, 326, + 0, 327, 328, 0, 330, 0, 331, 332, 333, 334, + 335, 336, 0, 337, 338, 0, 0, 339, 340, 341, + 0, 0, 342, 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 0, 0, 0, 0, 360, 361, 793, 363, 364, 365, + 0, 0, 0, 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, - 375, 0, 376, 377, 378, 1075, 380, 381, 382, 383, + 375, 0, 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 0, 397, 398, 399, 400, 401, - 402, 1076, 404, 405, 406, 407, 408, 409, 410, 411, + 393, 394, 395, 396, 0, 397, 398, 0, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, 428, - 1077, 430, 0, 431, 432, 433, 434, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 795, 0, 0, - 446, 447, 0, 448, 449, 450, 451, 452, 453, 454, - 0, 455, 1078, 1079, 0, 0, 458, 459, 796, 461, - 797, 1080, 463, 464, 798, 466, 467, 468, 469, 470, + 429, 430, 0, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 526, 444, 445, 0, 0, + 446, 447, 0, 448, 0, 450, 451, 452, 453, 454, + 0, 455, 456, 457, 0, 0, 458, 459, 460, 461, + 462, 0, 463, 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, - 0, 478, 479, 480, 481, 482, 483, 1081, 0, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 0, 0, + 0, 478, 479, 480, 481, 482, 483, 484, 0, 485, + 0, 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 0, 0, 0, 0, 0, 0, - 0, 1083, 1084, 1085, 0, 964, 1339, 815, 1086, 0, - 1087, 1046, 0, 0, 0, 1088, 1089, 1090, 1091, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 560, - 0, 0, 0, 0, 565, 129, 130, 0, 131, 132, - 133, 567, 135, 136, 137, 568, 569, 570, 571, 572, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 576, 577, 155, 0, 156, 157, 158, - 159, 579, 0, 581, 0, 583, 163, 164, 165, 166, - 167, 584, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 587, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 589, 190, 191, 590, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 600, 221, 222, 223, 224, 225, - 601, 1340, 227, 0, 228, 229, 604, 231, 0, 232, - 0, 233, 607, 0, 609, 236, 237, 610, 611, 240, - 0, 241, 0, 614, 615, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 617, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 620, 621, 268, 269, 270, 271, 272, 622, 623, 0, - 625, 0, 276, 627, 628, 279, 629, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 632, 289, 633, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 635, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 636, - 637, 638, 323, 324, 325, 639, 0, 327, 328, 641, - 330, 0, 643, 332, 644, 334, 335, 336, 0, 337, - 338, 1341, 0, 339, 340, 341, 0, 0, 342, 343, - 650, 651, 346, 652, 653, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 658, 659, 364, 365, 660, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 663, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 666, 400, 401, 402, 667, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 669, 417, 418, 419, 420, 421, 422, 670, - 424, 425, 0, 672, 427, 428, 673, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 675, 444, 676, 0, 0, 446, 447, 0, 448, - 680, 450, 451, 452, 453, 454, 0, 455, 682, 683, - 0, 0, 458, 459, 686, 461, 687, 1342, 463, 464, - 689, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 694, 695, 0, 485, 697, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 702, 703, 704, 705, 706, - 707, 708, 709, 710, 711, 712, 512, 513, 514, 515, - 0, 0, 0, 0, 0, 0, 0, 1343, 1344, 2344, - 0, 116, 1042, 815, 1043, 1044, 2345, 1046, 0, 0, - 0, 0, 0, 0, 1091, 0, 0, 0, 0, 0, - 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, - 126, 127, 0, 0, 0, 0, 0, 1048, 0, 0, - 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, - 137, 138, 1049, 140, 1050, 1051, 0, 143, 144, 145, - 146, 147, 148, 1052, 0, 149, 150, 151, 152, 1053, - 1054, 155, 0, 156, 157, 158, 159, 160, 0, 161, - 0, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 0, 172, 173, 174, 175, 176, 177, 0, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 1056, 190, 191, 1057, 193, 0, 194, 0, 195, 196, - 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, - 0, 0, 205, 206, 1059, 208, 209, 0, 210, 211, - 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, - 1060, 221, 222, 223, 224, 225, 226, 1061, 227, 0, - 228, 229, 1062, 231, 0, 232, 0, 233, 234, 0, - 235, 236, 237, 238, 239, 240, 0, 241, 3026, 1063, - 1064, 244, 245, 0, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 0, 258, 259, 260, - 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, - 270, 271, 272, 1065, 1066, 0, 1067, 0, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 0, - 0, 287, 288, 289, 290, 0, 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, 1069, 321, 1070, 323, 324, - 325, 326, 0, 327, 328, 329, 330, 1072, 331, 332, - 1073, 334, 335, 336, 0, 337, 338, 0, 0, 339, - 340, 341, 0, 0, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 0, 0, 0, 0, 360, 361, 362, 363, - 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, - 373, 374, 375, 0, 376, 377, 378, 1075, 380, 381, - 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 0, 397, 398, 399, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 0, 426, - 427, 428, 1077, 430, 0, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 0, 0, 446, 447, 0, 448, 449, 450, 451, 452, - 453, 454, 0, 455, 1078, 1079, 0, 0, 458, 459, - 460, 461, 462, 1080, 463, 464, 465, 466, 467, 468, - 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, - 476, 477, 0, 478, 479, 480, 481, 482, 483, 1081, - 0, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 0, 0, 0, 0, - 116, 1042, 815, 1043, 1044, 0, 1046, 0, 0, 0, - 1086, 0, 2719, 0, 0, 0, 0, 1088, 1089, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 1048, 0, 0, 128, - 129, 130, 0, 131, 132, 133, 134, 135, 136, 137, - 138, 1049, 140, 1050, 1051, 0, 143, 144, 145, 146, - 147, 148, 1052, 0, 149, 150, 151, 152, 1053, 1054, - 155, 0, 156, 157, 158, 159, 160, 0, 161, 0, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 1056, - 190, 191, 1057, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 1059, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 1060, - 221, 222, 223, 224, 225, 226, 1061, 227, 0, 228, - 229, 1062, 231, 0, 232, 0, 233, 234, 0, 235, - 236, 237, 238, 239, 240, 0, 241, 0, 1063, 1064, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, - 271, 272, 1065, 1066, 0, 1067, 0, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 288, 289, 290, 0, 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, 1069, 321, 1070, 323, 324, 325, - 326, 0, 327, 328, 329, 330, 1072, 331, 332, 1073, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 1075, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 426, 427, - 428, 1077, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 0, - 0, 446, 447, 0, 448, 449, 450, 451, 452, 453, - 454, 0, 455, 1078, 1079, 0, 0, 458, 459, 460, - 461, 462, 1080, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 1081, 0, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 0, 0, 0, 0, 523, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1086, - 0, 2719, 0, 0, 0, 0, 1088, 1089, 117, 118, + 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1463, 0, 0, 117, 118, 119, 120, 121, 122, 123, + 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 129, 130, 0, 131, 132, 133, + 0, 135, 136, 137, 138, 139, 0, 141, 142, 0, + 143, 144, 145, 146, 147, 148, 0, 0, 149, 150, + 151, 152, 153, 154, 155, 0, 156, 157, 158, 159, + 160, 0, 0, 0, 162, 163, 164, 165, 166, 167, + 0, 169, 170, 171, 0, 172, 173, 174, 175, 176, + 177, 0, 0, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 0, 194, + 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, + 202, 203, 204, 0, 0, 205, 206, 207, 208, 209, + 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 0, 227, 0, 228, 229, 230, 231, 0, 232, 0, + 233, 0, 0, 0, 236, 237, 524, 0, 240, 0, + 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, + 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, + 258, 259, 260, 261, 262, 263, 264, 0, 265, 0, + 267, 268, 269, 270, 271, 272, 273, 274, 0, 275, + 0, 276, 0, 0, 279, 0, 281, 282, 283, 284, + 285, 286, 0, 0, 287, 0, 289, 0, 0, 291, + 292, 293, 294, 295, 296, 297, 298, 525, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 0, + 322, 323, 324, 325, 326, 0, 327, 328, 0, 330, + 0, 331, 332, 333, 334, 335, 336, 0, 337, 338, + 0, 0, 339, 340, 341, 0, 0, 342, 343, 344, + 0, 346, 0, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, + 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, + 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, + 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, + 397, 398, 0, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 0, 0, 427, 428, 429, 430, 0, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 526, 444, 445, 0, 0, 446, 447, 0, 448, 0, + 450, 451, 452, 453, 454, 0, 455, 456, 457, 0, + 0, 458, 459, 460, 461, 462, 0, 463, 464, 465, + 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, + 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, + 482, 483, 484, 0, 485, 0, 487, 488, 489, 490, + 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 523, + 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2200, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, - 0, 0, 0, 0, 0, 0, 1000, 0, 0, 129, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, 155, @@ -392464,22 +397858,22 @@ static const yytype_int16 yytable[] = 191, 192, 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, 0, - 213, 214, 215, -524, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 0, 227, -524, 228, 229, - 230, 231, -524, 232, 0, 233, 0, 0, 0, 236, + 213, 214, 215, 0, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 0, 227, 0, 228, 229, + 230, 231, 0, 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, 271, - 272, 273, 274, -524, 275, 0, 276, 0, 0, 279, + 272, 273, 274, 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, 287, - 0, 289, 0, -524, 291, 292, 293, 294, 295, 296, + 0, 289, 0, 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, 334, - 335, 336, -524, 337, 338, 0, 0, 339, 340, 341, - 0, -524, 342, 343, 344, 0, 346, 0, 348, 349, + 335, 336, 0, 337, 338, 0, 0, 339, 340, 341, + 0, 0, 342, 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, @@ -392494,14 +397888,113 @@ static const yytype_int16 yytable[] = 446, 447, 0, 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, 470, - -524, 0, 471, 472, 473, 0, 474, 475, 476, 477, + 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1157, 0, 117, 118, 119, 120, 121, 122, 123, + 2436, 0, 0, 117, 118, 119, 120, 121, 122, 123, + 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 129, 130, 0, 131, 132, 133, + 0, 135, 136, 137, 138, 139, 0, 141, 142, 0, + 143, 144, 145, 146, 147, 148, 0, 0, 149, 150, + 151, 152, 153, 154, 155, 0, 156, 157, 158, 159, + 160, 0, 0, 0, 162, 163, 164, 165, 166, 167, + 0, 169, 170, 171, 0, 172, 173, 174, 175, 176, + 177, 0, 0, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 0, 194, + 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, + 202, 203, 204, 0, 0, 205, 206, 207, 208, 209, + 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 0, 227, 0, 228, 229, 230, 231, 0, 232, 0, + 233, 0, 0, 0, 236, 237, 524, 0, 240, 0, + 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, + 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, + 258, 259, 260, 261, 262, 263, 264, 0, 265, 0, + 267, 268, 269, 270, 271, 272, 273, 274, 0, 275, + 0, 276, 0, 0, 279, 0, 281, 282, 283, 284, + 285, 286, 0, 0, 287, 0, 289, 0, 0, 291, + 292, 293, 294, 295, 296, 297, 298, 525, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 0, + 322, 323, 324, 325, 326, 0, 327, 328, 0, 330, + 0, 331, 332, 333, 334, 335, 336, 0, 337, 338, + 0, 0, 339, 340, 341, 0, 0, 342, 343, 344, + 0, 346, 0, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, + 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, + 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, + 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, + 397, 398, 0, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 0, 0, 427, 428, 429, 430, 0, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 526, 444, 445, 0, 0, 446, 447, 0, 448, 0, + 450, 451, 452, 453, 454, 0, 455, 456, 457, 0, + 0, 458, 459, 460, 461, 462, 0, 463, 464, 465, + 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, + 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, + 482, 483, 484, 0, 485, 0, 487, 488, 489, 490, + 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 523, + 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2567, 0, 0, 117, 118, + 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 129, + 130, 0, 131, 132, 133, 0, 135, 136, 137, 138, + 139, 0, 141, 142, 0, 143, 144, 145, 146, 147, + 148, 0, 0, 149, 150, 151, 152, 153, 154, 155, + 0, 156, 157, 158, 159, 160, 0, 0, 0, 162, + 163, 164, 165, 166, 167, 0, 169, 170, 171, 0, + 172, 173, 174, 175, 176, 177, 0, 0, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 0, 194, 0, 195, 196, 197, 198, + 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, + 205, 206, 207, 208, 209, 0, 210, 211, 212, 0, + 213, 214, 215, 0, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 0, 227, 0, 228, 229, + 230, 231, 0, 232, 0, 233, 0, 0, 0, 236, + 237, 524, 0, 240, 0, 241, 0, 242, 243, 244, + 245, 0, 246, 247, 248, 249, 250, 251, 252, 0, + 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, + 263, 264, 0, 265, 0, 267, 268, 269, 270, 271, + 272, 273, 274, 0, 275, 0, 276, 0, 0, 279, + 0, 281, 282, 283, 284, 285, 286, 0, 0, 287, + 0, 289, 0, 0, 291, 292, 293, 294, 295, 296, + 297, 298, 525, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 0, 322, 323, 324, 325, 326, + 0, 327, 328, 0, 330, 0, 331, 332, 333, 334, + 335, 336, 0, 337, 338, 0, 0, 339, 340, 341, + 0, 0, 342, 343, 344, 0, 346, 0, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 0, 0, 0, 0, 360, 361, 362, 0, 364, 365, + 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, + 375, 0, 376, 377, 378, 379, 380, 381, 382, 383, + 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 0, 397, 398, 0, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 0, 0, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 0, 0, 427, 428, + 429, 430, 0, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 526, 444, 445, 0, 0, + 446, 447, 0, 448, 0, 450, 451, 452, 453, 454, + 0, 455, 456, 457, 0, 0, 458, 459, 460, 461, + 462, 0, 463, 464, 465, 466, 467, 468, 469, 470, + 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, + 0, 478, 479, 480, 481, 482, 483, 484, 0, 485, + 0, 487, 488, 489, 490, 491, 492, 493, 0, 0, + 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3212, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, 0, @@ -392548,158 +398041,1120 @@ static const yytype_int16 yytable[] = 482, 483, 484, 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 512, 513, 514, 515, 964, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2429, 3212, 0, 117, 118, + 0, 0, 0, 0, 0, 2057, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, - 3, 4, 0, 560, 0, 0, 0, 0, 565, 129, - 130, 0, 131, 132, 133, 567, 135, 136, 137, 568, - 569, 570, 571, 572, 0, 143, 144, 145, 146, 147, - 148, 0, 0, 149, 150, 151, 152, 576, 577, 155, - 0, 156, 157, 158, 159, 579, 0, 581, 0, 583, - 163, 164, 165, 166, 167, 584, 169, 170, 171, 0, - 172, 173, 174, 175, 176, 177, 0, 587, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 589, 190, - 191, 590, 193, 0, 194, 0, 195, 196, 197, 198, - 199, 200, 14, 15, 201, 202, 203, 204, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 129, + 130, 0, 131, 132, 133, 0, 135, 136, 137, 138, + 139, 0, 141, 142, 0, 143, 144, 145, 146, 147, + 148, 0, 0, 149, 150, 151, 152, 153, 154, 155, + 0, 156, 157, 158, 159, 160, 0, 0, 0, 162, + 163, 164, 165, 166, 167, 0, 169, 170, 171, 0, + 172, 173, 174, 175, 176, 177, 0, 0, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 0, 194, 0, 195, 196, 197, 198, + 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, 0, - 213, 214, 215, 0, 216, 217, 218, 219, 600, 221, - 222, 223, 224, 225, 601, 0, 227, 0, 228, 229, - 604, 231, 0, 232, 0, 233, 607, 23, 609, 236, - 237, 610, 611, 240, 0, 241, 0, 614, 615, 244, - 245, 0, 246, 247, 248, 249, 250, 251, 252, 617, + 213, 214, 215, 0, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 0, 227, 0, 228, 229, + 230, 231, 0, 232, 0, 233, 0, 0, 0, 236, + 237, 524, 0, 240, 0, 241, 0, 242, 243, 244, + 245, 0, 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, - 263, 264, 0, 265, 620, 621, 268, 269, 270, 271, - 272, 622, 623, 0, 625, 0, 276, 627, 628, 279, - 629, 281, 282, 283, 284, 285, 286, 0, 0, 287, - 632, 289, 633, 0, 291, 292, 293, 294, 295, 296, - 297, 298, 635, 300, 301, 302, 303, 304, 305, 306, + 263, 264, 0, 265, 0, 267, 268, 269, 270, 271, + 272, 273, 274, 0, 275, 0, 276, 0, 0, 279, + 0, 281, 282, 283, 284, 285, 286, 0, 0, 287, + 0, 289, 0, 0, 291, 292, 293, 294, 295, 296, + 297, 298, 525, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 636, 637, 638, 323, 324, 325, 639, - 0, 327, 328, 641, 330, 0, 643, 332, 644, 334, + 317, 318, 319, 320, 0, 322, 323, 324, 325, 326, + 0, 327, 328, 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, 341, - 0, 0, 342, 343, 650, 651, 346, 652, 653, 349, + 0, 0, 342, 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 27, 28, 29, 0, 360, 361, 658, 659, 364, 365, - 660, 367, 368, 369, 0, 370, 371, 372, 373, 374, - 375, 0, 376, 377, 378, 663, 380, 381, 382, 383, + 0, 0, 0, 0, 360, 361, 362, 0, 364, 365, + 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, + 375, 0, 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 0, 397, 398, 666, 400, 401, - 402, 667, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 34, 669, 417, 418, 419, - 420, 421, 422, 670, 424, 425, 36, 672, 427, 428, - 673, 430, 0, 431, 432, 433, 434, 435, 436, 437, - 438, 439, 440, 441, 442, 675, 444, 676, 38, 0, - 446, 447, 39, 448, 680, 450, 451, 452, 453, 454, - 0, 455, 682, 683, 0, 0, 458, 459, 686, 461, - 687, 0, 463, 464, 689, 466, 467, 468, 469, 470, - 0, 0, 471, 472, 473, 41, 474, 475, 476, 477, - 0, 478, 479, 480, 481, 482, 965, 695, 0, 485, - 697, 487, 488, 489, 490, 491, 492, 493, 0, 0, - 494, 0, 45, 495, 496, 497, 498, 499, 500, 702, - 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, - 512, 513, 514, 515, 0, 116, 46, 549, 0, 0, + 393, 394, 395, 396, 0, 397, 398, 0, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 0, 0, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 0, 0, 427, 428, + 429, 430, 0, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 526, 444, 445, 0, 0, + 446, 447, 0, 448, 0, 450, 451, 452, 453, 454, + 0, 455, 456, 457, 0, 0, 458, 459, 460, 461, + 462, 0, 463, 464, 465, 466, 467, 468, 469, 470, + 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, + 0, 478, 479, 480, 481, 482, 483, 484, 0, 485, + 0, 487, 488, 489, 490, 491, 492, 493, 0, 0, + 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2160, 0, 0, 117, 118, 119, 120, 121, 122, 123, + 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 129, 130, 0, 131, 132, 133, + 0, 135, 136, 137, 138, 139, 0, 141, 142, 0, + 143, 144, 145, 146, 147, 148, 0, 0, 149, 150, + 151, 152, 153, 154, 155, 0, 156, 157, 158, 159, + 160, 0, 0, 0, 162, 163, 164, 165, 166, 167, + 0, 169, 170, 171, 0, 172, 173, 174, 175, 176, + 177, 0, 0, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 0, 194, + 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, + 202, 203, 204, 0, 0, 205, 206, 207, 208, 209, + 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 0, 227, 0, 228, 229, 230, 231, 0, 232, 0, + 233, 0, 0, 0, 236, 237, 524, 0, 240, 0, + 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, + 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, + 258, 259, 260, 261, 262, 263, 264, 0, 265, 0, + 267, 268, 269, 270, 271, 272, 273, 274, 0, 275, + 0, 276, 0, 0, 279, 0, 281, 282, 283, 284, + 285, 286, 0, 0, 287, 0, 289, 0, 0, 291, + 292, 293, 294, 295, 296, 297, 298, 525, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 0, + 322, 323, 324, 325, 326, 0, 327, 328, 0, 330, + 0, 331, 332, 333, 334, 335, 336, 0, 337, 338, + 0, 0, 339, 340, 341, 0, 0, 342, 343, 344, + 0, 346, 0, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, + 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, + 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, + 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, + 397, 398, 0, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 0, 0, 427, 428, 429, 430, 0, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 526, 444, 445, 0, 0, 446, 447, 0, 448, 0, + 450, 451, 452, 453, 454, 0, 455, 456, 457, 0, + 0, 458, 459, 460, 461, 462, 0, 463, 464, 465, + 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, + 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, + 482, 483, 484, 0, 485, 0, 487, 488, 489, 490, + 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 0, + 2892, 1340, 815, 0, 0, 2033, 1046, 0, 0, 0, + 0, 0, 2034, 2035, 0, 3073, 2036, 2037, 2038, 117, + 118, 119, 120, 121, 122, 123, 124, 556, 125, 126, + 127, 557, 558, 559, 2893, 561, 562, 563, 564, 2894, + 129, 130, 566, 131, 132, 133, 2895, 135, 136, 137, + 0, 1479, 2896, 1481, 1482, 573, 143, 144, 145, 146, + 147, 148, 574, 575, 149, 150, 151, 152, 1483, 1484, + 155, 578, 156, 157, 158, 159, 0, 580, 2897, 582, + 2898, 163, 164, 165, 166, 167, 2899, 169, 170, 171, + 585, 172, 173, 174, 175, 176, 177, 586, 2900, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 1489, + 190, 191, 1490, 193, 591, 194, 592, 195, 196, 197, + 198, 199, 200, 593, 594, 201, 202, 203, 204, 595, + 596, 205, 206, 1059, 208, 209, 597, 210, 211, 212, + 598, 213, 214, 215, 599, 216, 217, 218, 219, 0, + 221, 222, 223, 224, 225, 0, 602, 227, 603, 228, + 229, 1491, 231, 605, 232, 606, 233, 2901, 608, 2902, + 236, 237, 2903, 2904, 240, 612, 241, 613, 0, 0, + 244, 245, 616, 246, 247, 248, 249, 250, 251, 252, + 2905, 254, 255, 256, 257, 618, 258, 259, 260, 261, + 262, 263, 264, 619, 265, 2906, 0, 268, 269, 270, + 271, 272, 1497, 1498, 624, 1499, 626, 276, 2907, 2908, + 279, 2909, 281, 282, 283, 284, 285, 286, 630, 631, + 287, 2910, 289, 2911, 634, 291, 292, 293, 294, 295, + 296, 297, 298, 2912, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 1506, 2913, 1508, 323, 324, 325, + 2914, 640, 327, 328, 2915, 330, 642, 0, 332, 1510, + 334, 335, 336, 645, 337, 338, 646, 647, 2916, 340, + 341, 648, 649, 342, 343, 0, 2917, 346, 2918, 0, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 654, 655, 656, 657, 360, 361, 0, 2919, 364, + 365, 0, 367, 368, 369, 661, 370, 371, 372, 373, + 374, 375, 662, 376, 377, 378, 1514, 380, 381, 382, + 383, 664, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 665, 397, 398, 2920, 400, + 401, 402, 1516, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 668, 2921, 417, 418, + 419, 420, 421, 422, 2922, 424, 425, 671, 2923, 427, + 428, 1520, 430, 674, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 2924, 444, 0, 677, + 678, 446, 447, 679, 448, 2925, 450, 451, 452, 453, + 454, 681, 455, 1523, 1524, 684, 685, 458, 459, 0, + 461, 0, 688, 463, 464, 2926, 466, 467, 468, 469, + 470, 2927, 691, 471, 472, 473, 692, 474, 475, 476, + 477, 693, 478, 479, 480, 481, 482, 0, 1527, 696, + 485, 2928, 487, 488, 489, 490, 491, 492, 493, 698, + 699, 494, 700, 701, 495, 496, 497, 498, 499, 500, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 512, 513, 514, 515, 0, 523, 0, 2039, 2040, + 2041, 2033, 2929, 2930, 2044, 2045, 2046, 2047, 2034, 2035, + 0, 0, 2036, 2037, 2038, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 0, 0, 0, 2039, 2040, 2041, 0, 2042, 2043, + 2044, 2045, 2046, 2047, 1610, 0, 0, 1611, 0, 0, + 0, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1619, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1621, 1610, 0, 0, 1611, 0, 0, 1622, + 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1619, 0, 0, 0, 0, 1623, 0, 0, 0, + 0, 1621, 1610, 0, 0, 1611, 0, 0, 1622, 1612, + 1613, 1614, 1615, 1616, 1617, 1618, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1619, 0, 0, 0, 0, 1623, 0, 0, 0, 0, + 1621, 0, 0, 0, 0, 0, 0, 1622, 0, 1610, + 0, 0, 1611, 0, 0, 0, 1612, 1613, 1614, 1615, + 1616, 1617, 1618, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1623, 0, 0, 1619, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1621, 1610, 0, + 0, 1611, 1624, 0, 1622, 1612, 1613, 1614, 1615, 1616, + 1617, 1618, 0, 0, 0, 0, 0, 0, 0, 1625, + 0, 0, 0, 0, 1626, 0, 1619, 0, 0, 0, + 0, 1623, 0, 0, 0, 0, 1621, 0, 0, 0, + 0, 1624, 0, 1622, 0, 0, 0, 1627, 1628, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1625, 0, + 0, 0, 1629, 1626, 0, 0, 0, 0, 0, 0, + 1623, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1624, 0, 0, 0, 0, 0, 1627, 1628, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1625, 0, 0, + 1630, 1629, 1626, 1631, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1632, 0, 0, + 1633, 0, 0, 0, 0, 1627, 1628, 1624, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1630, + 1629, 0, 1631, 0, 1625, 0, 0, 0, 0, 1626, + 0, 0, 0, 0, 0, 0, 1632, 0, 0, 1633, + 0, 0, 0, 0, 0, 0, 1624, 0, 0, 0, + 0, 0, 1627, 1628, 0, 0, 0, 0, 1630, 0, + 0, 1631, 0, 1625, 0, 0, 0, 1629, 1626, 0, + 0, 0, 0, 0, 0, 1632, 0, 0, 1633, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1627, 1628, 0, 0, 0, 0, 1634, 0, 0, + 0, 0, 0, 0, 0, 1630, 1629, 0, 1631, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1632, 0, 0, 1633, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1634, 0, 0, 0, + 0, 0, 0, 0, 1630, 0, 0, 1631, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1632, 0, 0, 1633, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1634, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1635, 0, 0, 1636, 1637, 1638, + 0, 1639, 1640, 1641, 1642, 1643, 1644, 0, 0, 0, + 0, 2838, 1634, 0, 0, 0, 0, 0, 1610, 0, + 0, 1611, 0, 0, 0, 1612, 1613, 1614, 1615, 1616, + 1617, 1618, 0, 1635, 0, 0, 1636, 1637, 1638, 0, + 1639, 1640, 1641, 1642, 1643, 1644, 1619, 0, 0, 0, + 3065, 1634, 0, 0, 0, 0, 1621, 0, 0, 0, + 0, 0, 0, 1622, 0, 0, 0, 0, 0, 0, + 0, 0, 1635, 0, 0, 1636, 1637, 1638, 0, 1639, + 1640, 1641, 1642, 1643, 1644, 0, 0, 0, 0, 3072, + 1623, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1610, 0, 0, 1611, 0, 0, + 0, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, 1635, + 0, 0, 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, + 1643, 1644, 1619, 0, 0, 0, 3232, 0, 0, 0, + 0, 0, 1621, 1610, 0, 0, 1611, 0, 0, 1622, + 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, 1635, 0, + 0, 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, + 1644, 1619, 0, 0, 0, 3254, 1623, 0, 0, 0, + 0, 1621, 1610, 0, 0, 1611, 1624, 0, 1622, 1612, + 1613, 1614, 1615, 1616, 1617, 1618, 0, 0, 0, 0, + 0, 0, 0, 1625, 0, 0, 0, 0, 1626, 0, + 1619, 0, 0, 0, 0, 1623, 0, 0, 0, 0, + 1621, 0, 0, 0, 0, 0, 0, 1622, 0, 0, + 0, 1627, 1628, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1629, 0, 0, 0, + 0, 0, 0, 0, 1623, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1610, 0, + 0, 1611, 1624, 0, 0, 1612, 1613, 1614, 1615, 1616, + 1617, 1618, 0, 0, 1630, 0, 0, 1631, 0, 1625, + 0, 0, 0, 0, 1626, 0, 1619, 0, 0, 0, + 0, 1632, 0, 0, 1633, 0, 1621, 0, 0, 0, + 0, 1624, 0, 1622, 0, 0, 0, 1627, 1628, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1625, 0, + 0, 0, 1629, 1626, 0, 0, 0, 0, 0, 0, + 1623, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1624, 0, 0, 0, 0, 0, 1627, 1628, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1625, 0, 0, + 1630, 1629, 1626, 1631, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1632, 0, 0, + 1633, 0, 0, 0, 0, 1627, 1628, 0, 0, 0, + 0, 1634, 0, 0, 0, 0, 0, 0, 0, 1630, + 1629, 0, 1631, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1632, 0, 0, 1633, + 0, 0, 0, 0, 0, 0, 1624, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1630, 0, + 0, 1631, 0, 1625, 0, 0, 0, 0, 1626, 0, + 0, 0, 0, 0, 0, 1632, 0, 0, 1633, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1627, 1628, 0, 0, 0, 0, 1634, 0, 0, + 0, 0, 0, 0, 0, 0, 1629, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1635, 0, + 0, 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, + 1644, 0, 0, 0, 0, 3355, 1634, 0, 0, 0, + 0, 0, 0, 0, 1630, 0, 1610, 1631, 0, 1611, + 0, 0, 0, 1612, 1613, 1614, 1615, 1616, 1617, 1618, + 0, 1632, 0, 0, 1633, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1619, 1634, 717, 0, 0, 0, + 0, 0, 0, 0, 1621, 0, 0, 0, 0, 0, + 0, 1622, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1635, 0, 0, 1636, 1637, 1638, + 0, 1639, 1640, 1641, 1642, 1643, 1644, 0, 1623, 0, + 0, 3412, 0, 0, 0, 0, 0, 0, 1610, 0, + 0, 1611, 0, 718, 0, 1612, 1613, 1614, 1615, 1616, + 1617, 1618, 0, 1635, 0, 0, 1636, 1637, 1638, 719, + 1639, 1640, 1641, 1642, 1643, 1644, 1619, 0, 0, 0, + 3434, 1634, 0, 0, 0, 0, 1621, 0, 0, 0, + 0, 0, 0, 1622, 0, 0, 0, 0, 0, 0, + 0, 0, 1635, 0, 0, 1636, 1637, 1638, 0, 1639, + 1640, 1641, 1642, 1643, 1644, 0, 0, 1795, 720, 0, + 1623, 0, 0, 0, 0, 0, 0, 0, 721, 0, + 0, 0, 0, 0, 1624, 0, 0, 0, 0, 0, + 722, 0, 0, 0, 0, 723, 0, 0, 0, 0, + 0, 1625, 0, 0, 0, 0, 1626, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 724, 0, 0, 0, 0, 1627, + 1628, 0, 0, 0, 0, 0, 0, 0, 1635, 0, + 0, 1636, 1637, 1638, 1629, 1639, 1640, 1641, 1642, 1643, + 1644, 0, 0, 2792, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1624, 725, 0, 0, + 0, 726, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1630, 1625, 0, 1631, 0, 0, 1626, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1632, + 0, 0, 1633, 0, 0, 0, 0, 0, 0, 0, + 0, 1627, 1628, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1629, 0, 0, 0, + 0, 0, 0, 0, 0, 539, 0, 0, 0, 0, + 0, 727, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 728, 0, 0, 0, + 0, 0, 0, 0, 1630, 0, 0, 1631, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1632, 0, 0, 1633, 0, 0, 0, 0, 729, + 0, 0, 730, 0, 0, 0, 0, 0, 0, 1634, + 0, 0, 0, 731, 0, 0, 732, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 733, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 734, 0, + 0, 0, 0, 0, 735, 736, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 737, 0, 0, 0, 0, + 0, 738, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1634, 0, 0, 0, 0, 0, 0, 739, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1635, 0, 0, 1636, + 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, 0, + 0, 3222, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 47, 0, 0, 0, 117, 118, 119, 120, 121, 122, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 555, 0, 0, 1635, 0, + 0, 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, + 1644, 0, 0, 3396, 117, 118, 119, 120, 121, 122, + 123, 124, 556, 125, 126, 127, 557, 558, 559, 560, + 561, 562, 563, 564, 565, 129, 130, 566, 131, 132, + 133, 567, 135, 136, 137, 568, 569, 570, 571, 572, + 573, 143, 144, 145, 146, 147, 148, 574, 575, 149, + 150, 151, 152, 576, 577, 155, 578, 156, 157, 158, + 159, 579, 580, 581, 582, 583, 163, 164, 165, 166, + 167, 584, 169, 170, 171, 585, 172, 173, 174, 175, + 176, 177, 586, 587, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 589, 190, 191, 590, 193, 591, + 194, 592, 195, 196, 197, 198, 199, 200, 593, 594, + 201, 202, 203, 204, 595, 596, 205, 206, 207, 208, + 209, 597, 210, 211, 212, 598, 213, 214, 215, 599, + 216, 217, 218, 219, 600, 221, 222, 223, 224, 225, + 601, 602, 227, 603, 228, 229, 604, 231, 605, 232, + 606, 233, 607, 608, 609, 236, 237, 610, 611, 240, + 612, 241, 613, 614, 615, 244, 245, 616, 246, 247, + 248, 249, 250, 251, 252, 617, 254, 255, 256, 257, + 618, 258, 259, 260, 261, 262, 263, 264, 619, 265, + 620, 621, 268, 269, 270, 271, 272, 622, 623, 624, + 625, 626, 276, 627, 628, 279, 629, 281, 282, 283, + 284, 285, 286, 630, 631, 287, 632, 289, 633, 634, + 291, 292, 293, 294, 295, 296, 297, 298, 635, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 636, + 637, 638, 323, 324, 325, 639, 640, 327, 328, 641, + 330, 642, 643, 332, 644, 334, 335, 336, 645, 337, + 338, 646, 647, 339, 340, 341, 648, 649, 342, 343, + 650, 651, 346, 652, 653, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 654, 655, 656, 657, + 360, 361, 658, 659, 364, 365, 660, 367, 368, 369, + 661, 370, 371, 372, 373, 374, 375, 662, 376, 377, + 378, 663, 380, 381, 382, 383, 664, 384, 385, 386, + 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 665, 397, 398, 666, 400, 401, 402, 667, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 668, 669, 417, 418, 419, 420, 421, 422, 670, + 424, 425, 671, 672, 427, 428, 673, 430, 674, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 675, 444, 676, 677, 678, 446, 447, 679, 448, + 680, 450, 451, 452, 453, 454, 681, 455, 682, 683, + 684, 685, 458, 459, 686, 461, 687, 688, 463, 464, + 689, 466, 467, 468, 469, 470, 690, 691, 471, 472, + 473, 692, 474, 475, 476, 477, 693, 478, 479, 480, + 481, 482, 694, 695, 696, 485, 697, 487, 488, 489, + 490, 491, 492, 493, 698, 699, 494, 700, 701, 495, + 496, 497, 498, 499, 500, 702, 703, 704, 705, 706, + 707, 708, 709, 710, 711, 712, 512, 513, 514, 515, + 523, 0, 0, 0, 0, 0, 0, 0, 0, 2068, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, + 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, + 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, + 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, + 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, + 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, + 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, + 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, + 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, + 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, + 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, + 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, + 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, + 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, + 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, + 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, + 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, + 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, + 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, + 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, + 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, + 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, + 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, + 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, + 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, + 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, + 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, + 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, + 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, + 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, + 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, + 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, + 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, + 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, + 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, + 0, 0, 0, 0, 2692, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 128, 129, 130, 0, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 785, 149, + 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, + 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, + 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 786, 0, 787, 0, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 178, 179, 180, 181, 182, 183, 184, + 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, + 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, + 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 14, 15, + 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 788, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 234, 23, 235, 236, 237, 238, 239, 240, + 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, + 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 789, 0, 287, 288, 289, 290, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, + 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, + 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, + 291, 292, 293, 294, 295, 296, 297, 298, 525, 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, 0, 327, 328, 329, - 330, 0, 790, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 791, 339, 340, 341, 0, 0, 342, 343, - 344, 345, 346, 347, 792, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 27, 28, 29, 0, - 360, 361, 793, 363, 364, 365, 366, 367, 368, 369, + 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, + 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, + 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, + 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, + 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 399, 400, 401, 402, 403, 794, 405, + 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 34, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 36, 426, 427, 428, 429, 430, 0, 431, + 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, + 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 795, 38, 0, 446, 447, 39, 448, - 449, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 796, 461, 797, 0, 463, 464, - 798, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 41, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 799, 484, 0, 485, 486, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 45, 495, + 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, + 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, + 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, + 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, + 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, + 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, + 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 0, 116, 46, 549, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 800, 0, 0, 0, + 964, 1340, 815, 0, 0, 0, 1046, 0, 0, 2695, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, + 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, + 127, 0, 0, 0, 560, 0, 0, 0, 0, 565, + 129, 130, 0, 131, 132, 133, 567, 135, 136, 137, + 568, 569, 570, 571, 572, 0, 143, 144, 145, 146, + 147, 148, 0, 0, 149, 150, 151, 152, 576, 577, + 155, 0, 156, 157, 158, 159, 579, 0, 581, 0, + 583, 163, 164, 165, 166, 167, 584, 169, 170, 171, + 0, 172, 173, 174, 175, 176, 177, 0, 587, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 589, + 190, 191, 590, 193, 0, 194, 0, 195, 196, 197, + 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, + 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, + 0, 213, 214, 215, 0, 216, 217, 218, 219, 600, + 221, 222, 223, 224, 225, 601, 1341, 227, 0, 228, + 229, 604, 231, 0, 232, 0, 233, 607, 0, 609, + 236, 237, 610, 611, 240, 0, 241, 0, 614, 615, + 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, + 617, 254, 255, 256, 257, 0, 258, 259, 260, 261, + 262, 263, 264, 0, 265, 620, 621, 268, 269, 270, + 271, 272, 622, 623, 0, 625, 0, 276, 627, 628, + 279, 629, 281, 282, 283, 284, 285, 286, 0, 0, + 287, 632, 289, 633, 0, 291, 292, 293, 294, 295, + 296, 297, 298, 635, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 636, 637, 638, 323, 324, 325, + 639, 0, 327, 328, 641, 330, 0, 643, 332, 644, + 334, 335, 336, 0, 337, 338, 1342, 0, 339, 340, + 341, 0, 0, 342, 343, 650, 651, 346, 652, 653, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 0, 0, 0, 0, 360, 361, 658, 659, 364, + 365, 660, 367, 368, 369, 0, 370, 371, 372, 373, + 374, 375, 0, 376, 377, 378, 663, 380, 381, 382, + 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 0, 397, 398, 666, 400, + 401, 402, 667, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 0, 669, 417, 418, + 419, 420, 421, 422, 670, 424, 425, 0, 672, 427, + 428, 673, 430, 0, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 675, 444, 676, 0, + 0, 446, 447, 0, 448, 680, 450, 451, 452, 453, + 454, 0, 455, 682, 683, 0, 0, 458, 459, 686, + 461, 687, 1343, 463, 464, 689, 466, 467, 468, 469, + 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, + 477, 0, 478, 479, 480, 481, 482, 694, 695, 0, + 485, 697, 487, 488, 489, 490, 491, 492, 493, 0, + 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, + 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, + 712, 512, 513, 514, 515, 0, 0, 1610, 0, 0, + 1611, 0, 1344, 1345, 1612, 1613, 1614, 1615, 1616, 1617, + 1618, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1619, 0, 0, 0, 0, + 2166, 0, 0, 0, 0, 1621, 1610, 0, 0, 1611, + 0, 0, 1622, 1612, 1613, 1614, 1615, 1616, 1617, 1618, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1619, 0, 0, 0, 0, 1623, + 0, 0, 0, 0, 1621, 1610, 0, 0, 1611, 0, + 0, 1622, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1619, 0, 0, 0, 0, 1623, 0, + 0, 0, 0, 1621, 0, 2167, 0, 0, 0, 0, + 1622, 0, 0, 1610, 0, 0, 1611, 0, 0, 0, + 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1623, 0, 0, + 0, 1619, 0, 0, 0, 1889, 0, 0, 0, 0, + 0, 1621, 0, 1610, 0, 1624, 1611, 0, 1622, 0, + 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, 0, 0, + 0, 0, 1625, 0, 0, 0, 0, 1626, 0, 0, + 0, 1619, 0, 0, 1925, 1623, 0, 0, 0, 1926, + 0, 1621, 0, 0, 1624, 0, 0, 0, 1622, 0, + 1627, 1628, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1625, 0, 0, 0, 1629, 1626, 0, 0, 0, + 0, 0, 3502, 0, 0, 1623, 0, 0, 0, 0, + 0, 0, 0, 1624, 0, 0, 0, 0, 0, 1627, + 1628, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1625, 0, 0, 1630, 1629, 1626, 1631, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1632, 0, 0, 1633, 0, 0, 0, 0, 1627, 1628, + 0, 1624, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1630, 1629, 0, 1631, 0, 0, 1625, 0, + 0, 0, 0, 1626, 0, 0, 0, 0, 0, 1632, + 0, 0, 1633, 0, 0, 0, 0, 0, 0, 0, + 0, 1624, 0, 0, 0, 0, 1627, 1628, 0, 0, + 0, 1630, 0, 0, 1631, 0, 0, 0, 1625, 0, + 0, 1629, 0, 1626, 0, 0, 0, 0, 1632, 0, + 0, 1633, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1627, 1628, 0, 0, + 1634, 0, 0, 0, 0, 0, 0, 0, 0, 1630, + 3503, 1629, 1631, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1632, 0, 0, 1633, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1634, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1630, + 0, 0, 1631, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2170, 0, 0, 1632, 0, 0, 1633, + 0, 0, 0, 0, 0, 0, 0, 0, 1634, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1896, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1635, 0, 0, + 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, + 0, 0, 0, 0, 0, 0, 1634, 0, 0, 0, + 0, 1610, 0, 0, 1611, 0, 0, 0, 1612, 1613, + 1614, 1615, 1616, 1617, 1618, 0, 1635, 0, 0, 1636, + 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, 1619, + 0, 0, 0, 1931, 0, 0, 1634, 0, 0, 1621, + 0, 0, 0, 0, 0, 0, 1622, 0, 0, 0, + 0, 0, 0, 0, 0, 1635, 0, 0, 1636, 1637, + 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, 0, 0, + 0, 0, 0, 1623, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1610, 0, + 0, 1611, 0, 0, 0, 1612, 1613, 1614, 1615, 1616, + 1617, 1618, 0, 1635, 0, 0, 1636, 1637, 1638, 0, + 1639, 1640, 1641, 1642, 1643, 1644, 1619, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1621, 0, 0, 0, + 0, 0, 0, 1622, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1635, 0, 0, 1636, 1637, 1638, 0, + 1639, 1640, 1641, 1642, 1643, 1644, 0, 0, 0, 0, + 1623, 0, 0, 0, 0, 1610, 0, 0, 1611, 1624, + 0, 0, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, + 0, 0, 0, 0, 0, 0, 1625, 0, 0, 0, + 0, 1626, 0, 1619, 0, 0, 0, 1938, 0, 0, + 0, 0, 0, 1621, 0, 0, 0, 0, 0, 0, + 1622, 0, 0, 0, 1627, 1628, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1629, + 0, 0, 0, 0, 0, 0, 0, 1623, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1936, 1610, 0, 0, 1611, 1624, 0, 0, 1612, + 1613, 1614, 1615, 1616, 1617, 1618, 0, 1630, 0, 0, + 1631, 0, 0, 1625, 0, 0, 0, 0, 1626, 0, + 1619, 0, 0, 0, 1632, 0, 0, 1633, 0, 0, + 1621, 0, 0, 0, 0, 0, 0, 1622, 0, 0, + 0, 1627, 1628, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1629, 0, 0, 0, + 0, 0, 0, 0, 1623, 0, 0, 0, 0, 0, + 0, 0, 0, 1624, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1625, 0, 0, 0, 1630, 1626, 0, 1631, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1632, 0, 0, 1633, 0, 0, 0, 1627, 1628, + 0, 0, 0, 0, 1634, 0, 0, 1610, 0, 0, + 1611, 0, 0, 1629, 1612, 1613, 1614, 1615, 1616, 1617, + 1618, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2061, 0, 0, 0, 0, 1619, 0, 0, 0, 0, + 1624, 0, 0, 0, 0, 1621, 0, 0, 0, 0, + 0, 1630, 1622, 0, 1631, 0, 0, 1625, 0, 0, + 0, 0, 1626, 0, 0, 0, 0, 0, 1632, 0, + 0, 1633, 0, 0, 0, 0, 0, 0, 0, 1623, + 0, 0, 0, 0, 0, 1627, 1628, 0, 0, 0, + 0, 1634, 0, 0, 0, 0, 0, 0, 0, 0, + 1629, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1635, 0, 0, 1636, 1637, 1638, 0, 1639, 1640, + 1641, 1642, 1643, 1644, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1630, 0, + 0, 1631, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1632, 0, 0, 1633, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1634, 0, + 0, 0, 0, 0, 0, 1624, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1625, 0, 0, 0, 0, 1626, 1635, 0, + 0, 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, + 1644, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1627, 1628, 0, 0, 0, 0, 0, 0, 0, 1610, + 0, 0, 1611, 0, 0, 1629, 1612, 1613, 1614, 1615, + 1616, 1617, 1618, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1634, 0, 1619, 0, 0, + 0, 2769, 0, 0, 0, 0, 0, 1621, 0, 0, + 0, 0, 0, 1630, 1622, 1635, 1631, 0, 1636, 1637, + 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, 0, 0, + 1632, 0, 0, 1633, 0, 0, 0, 0, 0, 0, + 0, 1623, 0, 1610, 0, 0, 1611, 0, 0, 0, + 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1619, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1621, 0, 0, 0, 0, 0, 0, 1622, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1635, 0, 0, 1636, 1637, 1638, 0, 1639, + 1640, 1641, 1642, 1643, 1644, 1623, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1634, 0, 1610, 0, 0, 1611, 0, 1624, 0, 1612, + 1613, 1614, 1615, 1616, 1617, 1618, 0, 0, 0, 0, + 0, 0, 0, 0, 1625, 0, 0, 0, 0, 1626, + 1619, 0, 0, 2756, 0, 0, 0, 0, 0, 0, + 1621, 0, 0, 0, 0, 0, 0, 1622, 0, 0, + 0, 0, 1627, 1628, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1629, 0, 0, + 0, 0, 0, 0, 1623, 0, 0, 0, 0, 0, + 0, 1624, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1625, 0, + 0, 0, 0, 1626, 0, 1630, 0, 1635, 1631, 0, + 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, + 0, 0, 1632, 0, 0, 1633, 1627, 1628, 0, 0, + 0, 0, 0, 0, 0, 1610, 0, 0, 1611, 0, + 0, 1629, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1619, 0, 0, 0, 0, 0, 0, + 1624, 0, 0, 1621, 0, 0, 0, 0, 0, 1630, + 1622, 0, 1631, 0, 0, 0, 0, 1625, 0, 0, + 0, 0, 1626, 0, 0, 0, 1632, 0, 0, 1633, + 0, 0, 0, 0, 0, 0, 1610, 1623, 0, 1611, + 0, 0, 0, 1612, 1613, 1805, 1628, 1616, 1617, 1618, + 0, 0, 1634, 0, 0, 0, 0, 0, 0, 0, + 1629, 0, 0, 0, 1619, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1621, 0, 0, 0, 0, 0, + 0, 1622, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1630, 0, + 0, 1631, 0, 0, 0, 0, 0, 0, 1623, 0, + 0, 0, 0, 0, 0, 1632, 0, 0, 1633, 0, + 0, 0, 0, 0, 0, 0, 1634, 1610, 0, 0, + 1611, 0, 0, 1624, 1612, 1613, 0, 0, 1616, 1617, + 1618, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1625, 0, 0, 0, 0, 1626, 0, 0, 0, 1635, + 0, 0, 1636, 1637, 1638, 1621, 1639, 1640, 1641, 1642, + 1643, 1644, 1622, 0, 0, 0, 0, 0, 1627, 1628, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1629, 0, 0, 0, 0, 0, 1623, + 0, 0, 0, 0, 1624, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1634, 0, 0, 0, 0, + 0, 1625, 0, 0, 0, 0, 1626, 0, 0, 0, + 0, 1630, 0, 1635, 1631, 0, 1636, 1637, 1638, 0, + 1639, 1640, 1641, 1642, 1643, 1644, 0, 0, 1632, 1627, + 1628, 1633, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1629, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1624, 0, 0, 0, 0, + 0, 0, 1630, 0, 0, 1631, 0, 0, 0, 0, + 0, 0, 1625, 0, 0, 0, 0, 1626, 0, 1632, + 0, 0, 1635, 0, 0, 1636, 1637, 1638, 0, 1639, + 1640, 1641, 1642, 1643, 1644, 0, 0, 0, 0, 0, + -2044, -2044, 0, 0, 0, 0, 0, 0, 1634, 0, + 0, 0, 0, 0, 0, 1629, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -2044, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1632, 0, 0, 0, 0, 0, 0, 0, 0, 1634, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1635, 0, 0, 1636, 1637, + 1638, 0, 1639, 1640, 1641, 1642, 2187, 1644, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1634, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1635, 0, 0, 1636, + 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 555, 0, 2084, 0, 0, 0, 1635, 0, 0, + 1636, 1637, 1638, 0, 1639, 1640, 1641, 1642, 1643, 1644, + 117, 118, 119, 120, 121, 122, 123, 124, 556, 125, + 126, 127, 557, 558, 559, 560, 561, 562, 563, 564, + 565, 129, 130, 566, 131, 132, 133, 567, 135, 136, + 137, 568, 569, 570, 571, 572, 573, 143, 144, 145, + 146, 147, 148, 574, 575, 149, 150, 151, 152, 576, + 577, 155, 578, 156, 157, 158, 159, 579, 580, 581, + 582, 583, 163, 164, 165, 166, 167, 584, 169, 170, + 171, 585, 172, 173, 174, 175, 176, 177, 586, 587, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 589, 190, 191, 590, 193, 591, 194, 592, 195, 196, + 197, 198, 199, 200, 593, 594, 201, 202, 203, 204, + 595, 596, 205, 206, 207, 208, 209, 597, 210, 211, + 212, 598, 213, 214, 215, 599, 216, 217, 218, 219, + 600, 221, 222, 223, 224, 225, 601, 602, 227, 603, + 228, 229, 604, 231, 605, 232, 606, 233, 607, 608, + 609, 236, 237, 610, 611, 240, 612, 241, 613, 614, + 615, 244, 245, 616, 246, 247, 248, 249, 250, 251, + 252, 617, 254, 255, 256, 257, 618, 258, 259, 260, + 261, 262, 263, 264, 619, 265, 620, 621, 268, 269, + 270, 271, 272, 622, 623, 624, 625, 626, 276, 627, + 628, 279, 629, 281, 282, 283, 284, 285, 286, 630, + 631, 287, 632, 289, 633, 634, 291, 292, 293, 294, + 295, 296, 297, 298, 635, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 636, 637, 638, 323, 324, + 325, 639, 640, 327, 328, 641, 330, 642, 643, 332, + 644, 334, 335, 336, 645, 337, 338, 646, 647, 339, + 340, 341, 648, 649, 342, 343, 650, 651, 346, 652, + 653, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 654, 655, 656, 657, 360, 361, 658, 659, + 364, 365, 660, 367, 368, 369, 661, 370, 371, 372, + 373, 374, 375, 662, 376, 377, 378, 663, 380, 381, + 382, 383, 664, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 665, 397, 398, 666, + 400, 401, 402, 667, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 668, 669, 417, + 418, 419, 420, 421, 422, 670, 424, 425, 671, 672, + 427, 428, 673, 430, 674, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 675, 444, 676, + 677, 678, 446, 447, 679, 448, 680, 450, 451, 452, + 453, 454, 681, 455, 682, 683, 684, 685, 458, 459, + 686, 461, 687, 688, 463, 464, 689, 466, 467, 468, + 469, 470, 690, 691, 471, 472, 473, 692, 474, 475, + 476, 477, 693, 478, 479, 480, 481, 482, 694, 695, + 696, 485, 697, 487, 488, 489, 490, 491, 492, 493, + 698, 699, 494, 700, 701, 495, 496, 497, 498, 499, + 500, 702, 703, 704, 705, 706, 707, 708, 709, 710, + 711, 712, 512, 513, 514, 515, 555, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 556, 125, 126, 127, 557, 558, 559, + 560, 561, 562, 563, 564, 565, 129, 130, 566, 131, + 132, 133, 567, 135, 136, 137, 568, 569, 570, 571, + 572, 573, 143, 144, 145, 146, 147, 148, 574, 575, + 149, 150, 151, 152, 576, 577, 155, 578, 156, 157, + 158, 159, 579, 580, 581, 582, 583, 163, 164, 165, + 166, 167, 584, 169, 170, 171, 585, 172, 173, 174, + 175, 176, 177, 586, 587, 179, 180, 181, 182, 183, + 184, 588, 186, 187, 188, 589, 190, 191, 590, 193, + 591, 194, 592, 195, 196, 197, 198, 199, 200, 593, + 594, 201, 202, 203, 204, 595, 596, 205, 206, 207, + 208, 209, 597, 210, 211, 212, 598, 213, 214, 215, + 599, 216, 217, 218, 219, 600, 221, 222, 223, 224, + 225, 601, 602, 227, 603, 228, 229, 604, 231, 605, + 232, 606, 233, 607, 608, 609, 236, 237, 610, 611, + 240, 612, 241, 613, 614, 615, 244, 245, 616, 246, + 247, 248, 249, 250, 251, 252, 617, 254, 255, 256, + 257, 618, 258, 259, 260, 261, 262, 263, 264, 619, + 265, 620, 621, 268, 269, 270, 271, 272, 622, 623, + 624, 625, 626, 276, 627, 628, 279, 629, 281, 282, + 283, 284, 285, 286, 630, 631, 287, 632, 289, 633, + 634, 291, 292, 293, 294, 295, 296, 297, 298, 635, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 636, 637, 638, 323, 324, 325, 639, 640, 327, 328, + 641, 330, 642, 643, 332, 644, 334, 335, 336, 645, + 337, 338, 646, 647, 339, 340, 341, 648, 649, 342, + 343, 650, 651, 346, 652, 653, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 654, 655, 656, + 657, 360, 361, 658, 659, 364, 365, 660, 367, 368, + 369, 661, 370, 371, 372, 373, 374, 375, 662, 376, + 377, 378, 663, 380, 381, 382, 383, 664, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 665, 397, 398, 666, 400, 401, 402, 667, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 668, 669, 417, 418, 419, 420, 421, 422, + 670, 424, 425, 671, 672, 427, 428, 673, 430, 674, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 675, 444, 676, 677, 678, 446, 447, 679, + 448, 680, 450, 451, 452, 453, 454, 681, 455, 682, + 683, 684, 685, 458, 459, 686, 461, 687, 688, 463, + 464, 689, 466, 467, 468, 469, 470, 690, 691, 471, + 472, 473, 692, 474, 475, 476, 477, 693, 478, 479, + 480, 481, 482, 694, 695, 696, 485, 697, 487, 488, + 489, 490, 491, 492, 493, 698, 699, 494, 700, 701, + 495, 496, 497, 498, 499, 500, 702, 703, 704, 705, + 706, 707, 708, 709, 710, 711, 712, 512, 513, 514, + 515, 555, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 556, 125, + 126, 127, 557, 558, 559, 560, 561, 562, 563, 564, + 565, 129, 130, 566, 131, 132, 133, 567, 135, 136, + 137, 568, 569, 570, 571, 572, 573, 143, 144, 145, + 146, 147, 148, 574, 575, 149, 150, 151, 152, 576, + 577, 155, 578, 156, 157, 158, 159, 579, 580, 581, + 582, 583, 163, 164, 165, 166, 167, 584, 169, 170, + 171, 585, 172, 173, 174, 175, 176, 177, 586, 587, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 589, 190, 191, 590, 193, 591, 194, 592, 195, 196, + 197, 198, 199, 200, 593, 594, 201, 202, 203, 204, + 595, 596, 205, 206, 207, 208, 209, 597, 210, 211, + 212, 598, 213, 214, 215, 599, 216, 217, 218, 219, + 600, 221, 222, 223, 224, 225, 601, 602, 227, 603, + 228, 229, 604, 231, 605, 232, 606, 233, 607, 608, + 609, 236, 237, 610, 611, 240, 612, 241, 613, 614, + 615, 244, 245, 616, 246, 247, 248, 249, 250, 940, + 252, 617, 254, 255, 256, 257, 618, 258, 259, 260, + 261, 262, 263, 264, 619, 265, 620, 621, 268, 269, + 270, 271, 272, 622, 623, 624, 625, 626, 276, 627, + 628, 279, 629, 281, 282, 283, 284, 285, 286, 630, + 631, 287, 632, 289, 633, 634, 291, 292, 293, 294, + 295, 296, 297, 298, 635, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 636, 637, 638, 323, 324, + 325, 639, 640, 327, 328, 641, 330, 642, 643, 332, + 644, 334, 335, 336, 645, 337, 338, 646, 647, 339, + 340, 341, 648, 649, 342, 343, 650, 651, 346, 652, + 653, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 654, 655, 656, 657, 360, 361, 658, 659, + 364, 365, 660, 367, 368, 369, 661, 370, 371, 372, + 373, 374, 375, 662, 376, 377, 378, 663, 380, 381, + 382, 383, 664, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 665, 397, 398, 666, + 400, 401, 402, 667, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 668, 669, 417, + 418, 419, 420, 421, 422, 670, 424, 425, 671, 672, + 427, 428, 673, 430, 674, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 675, 444, 676, + 677, 678, 446, 447, 679, 448, 680, 450, 451, 452, + 453, 454, 681, 455, 682, 683, 684, 685, 458, 459, + 686, 461, 687, 688, 463, 464, 689, 466, 467, 468, + 469, 470, 690, 691, 471, 472, 473, 692, 474, 475, + 476, 477, 693, 478, 479, 480, 481, 482, 694, 695, + 696, 485, 697, 487, 488, 489, 490, 491, 492, 493, + 698, 699, 494, 700, 701, 495, 496, 497, 498, 499, + 500, 702, 703, 704, 705, 706, 707, 708, 709, 710, + 711, 712, 512, 513, 514, 515, 555, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 556, 125, 126, 127, 557, 558, 559, + 560, 561, 562, 563, 564, 565, 129, 130, 566, 131, + 132, 133, 567, 135, 136, 137, 568, 569, 570, 571, + 572, 573, 143, 144, 145, 146, 147, 148, 574, 575, + 149, 150, 151, 152, 576, 577, 155, 578, 156, 157, + 158, 159, 579, 580, 581, 582, 583, 163, 164, 165, + 166, 167, 584, 169, 170, 171, 585, 172, 173, 174, + 175, 176, 177, 586, 587, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 589, 190, 191, 590, 193, + 591, 194, 592, 195, 196, 197, 198, 199, 200, 593, + 594, 201, 202, 203, 204, 595, 596, 205, 206, 207, + 208, 209, 597, 210, 211, 212, 598, 213, 214, 215, + 599, 216, 217, 218, 219, 600, 221, 222, 223, 224, + 225, 601, 602, 227, 603, 228, 229, 604, 231, 605, + 232, 606, 233, 607, 608, 609, 236, 237, 610, 611, + 240, 612, 241, 613, 614, 615, 244, 245, 616, 246, + 247, 248, 249, 250, 251, 252, 617, 254, 255, 256, + 257, 618, 258, 259, 260, 261, 262, 263, 264, 619, + 265, 620, 621, 268, 269, 270, 271, 272, 622, 623, + 624, 625, 626, 276, 627, 628, 279, 629, 281, 282, + 283, 284, 285, 286, 630, 631, 287, 632, 289, 633, + 634, 291, 292, 293, 294, 295, 296, 297, 298, 635, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 636, 637, 638, 323, 324, 325, 639, 640, 327, 328, + 641, 330, 642, 643, 332, 644, 334, 335, 336, 645, + 337, 338, 646, 647, 339, 340, 341, 648, 649, 342, + 343, 650, 651, 346, 652, 653, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 654, 655, 656, + 657, 360, 361, 658, 659, 364, 365, 660, 367, 368, + 369, 661, 370, 371, 372, 373, 374, 375, 662, 376, + 377, 378, 663, 380, 381, 382, 383, 664, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 665, 397, 398, 666, 400, 401, 402, 667, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 668, 669, 417, 418, 419, 420, 421, 422, + 670, 424, 425, 671, 672, 427, 428, 673, 430, 674, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 675, 444, 676, 677, 678, 446, 447, 679, + 448, 680, 450, 451, 452, 453, 454, 681, 455, 682, + 683, 684, 685, 458, 459, 686, 461, 687, 688, 463, + 464, 689, 466, 467, 468, 469, 470, 690, 691, 471, + 472, 473, 692, 474, 475, 476, 477, 693, 478, 479, + 480, 481, 482, 694, 695, 696, 485, 697, 487, 488, + 489, 490, 491, 492, 493, 698, 699, 494, 700, 701, + 495, 496, 497, 498, 499, 500, 702, 703, 704, 705, + 706, 707, 708, 709, 710, 711, 712, 512, 513, 514, + 515, 555, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 119, 120, 2232, 122, 123, 124, 556, 125, + 126, 127, 557, 558, 559, 560, 561, 562, 563, 564, + 565, 129, 130, 566, 131, 132, 133, 567, 135, 136, + 137, 568, 569, 570, 571, 572, 573, 143, 144, 145, + 146, 147, 148, 574, 575, 149, 150, 151, 152, 576, + 577, 155, 578, 156, 157, 158, 159, 579, 580, 581, + 582, 583, 163, 164, 165, 166, 167, 584, 169, 170, + 171, 585, 172, 173, 174, 175, 176, 177, 586, 587, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 589, 190, 191, 590, 193, 591, 194, 592, 195, 196, + 197, 198, 199, 200, 593, 594, 201, 202, 203, 204, + 595, 596, 205, 206, 207, 2233, 209, 597, 210, 211, + 212, 598, 213, 214, 215, 599, 216, 217, 218, 219, + 600, 221, 222, 223, 224, 225, 601, 602, 227, 603, + 228, 229, 604, 231, 605, 232, 606, 233, 607, 608, + 609, 236, 237, 610, 611, 240, 612, 241, 613, 614, + 615, 244, 245, 616, 246, 247, 248, 249, 250, 251, + 252, 617, 254, 255, 256, 257, 618, 258, 259, 260, + 261, 262, 263, 264, 619, 265, 620, 621, 268, 269, + 270, 271, 272, 622, 623, 624, 625, 626, 276, 627, + 628, 279, 629, 281, 282, 283, 284, 285, 286, 630, + 631, 287, 632, 289, 633, 634, 291, 292, 293, 294, + 295, 296, 297, 298, 635, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 636, 637, 638, 323, 324, + 325, 639, 640, 327, 328, 641, 330, 642, 643, 332, + 644, 334, 335, 336, 645, 337, 338, 646, 647, 339, + 340, 341, 648, 649, 342, 343, 650, 651, 346, 652, + 653, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 654, 655, 656, 657, 360, 361, 658, 659, + 364, 365, 660, 367, 368, 369, 661, 370, 371, 372, + 373, 374, 375, 662, 376, 377, 378, 663, 380, 381, + 382, 383, 664, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 665, 397, 398, 666, + 400, 401, 402, 667, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 668, 669, 417, + 418, 419, 420, 421, 2234, 670, 424, 425, 671, 672, + 427, 428, 673, 430, 674, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 675, 444, 676, + 677, 678, 446, 447, 679, 448, 680, 450, 451, 452, + 453, 454, 681, 455, 682, 683, 684, 685, 458, 459, + 686, 461, 687, 688, 463, 464, 689, 466, 467, 468, + 469, 470, 690, 691, 471, 472, 473, 692, 474, 475, + 476, 477, 693, 478, 479, 480, 481, 482, 694, 695, + 696, 485, 697, 487, 488, 489, 490, 491, 492, 493, + 698, 699, 494, 700, 701, 495, 496, 497, 498, 499, + 500, 702, 703, 704, 705, 706, 707, 708, 709, 710, + 711, 712, 512, 513, 514, 515, 964, 0, 815, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 560, 0, 0, 0, 0, 565, 129, 130, 0, 131, + 132, 133, 567, 135, 136, 137, 568, 569, 570, 571, + 572, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 576, 577, 155, 0, 156, 157, + 158, 159, 579, 0, 581, 0, 583, 163, 164, 165, + 166, 167, 584, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 587, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 589, 190, 191, 590, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 600, 221, 222, 223, 224, + 225, 601, 1341, 227, 0, 228, 229, 604, 231, 0, + 232, 0, 233, 607, 0, 609, 236, 237, 610, 611, + 240, 0, 241, 0, 614, 615, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 617, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 620, 621, 268, 269, 270, 271, 272, 622, 623, + 0, 625, 0, 276, 627, 628, 279, 629, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 632, 289, 633, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 635, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 636, 637, 638, 323, 324, 325, 639, 0, 327, 328, + 641, 330, 0, 643, 332, 644, 334, 335, 336, 0, + 337, 338, 1342, 0, 339, 340, 341, 0, 0, 342, + 343, 650, 651, 346, 652, 653, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 658, 659, 364, 365, 660, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 663, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 666, 400, 401, 402, 667, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 669, 417, 418, 419, 420, 421, 422, + 670, 424, 425, 0, 672, 427, 428, 673, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 675, 444, 676, 0, 0, 446, 447, 0, + 448, 680, 450, 451, 452, 453, 454, 0, 455, 682, + 683, 0, 0, 458, 459, 686, 461, 687, 1343, 463, + 464, 689, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 694, 695, 0, 485, 697, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 702, 703, 704, 705, + 706, 707, 708, 709, 710, 711, 712, 512, 513, 514, + 515, 964, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, - 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, - 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 0, 143, 144, 145, - 146, 147, 148, 0, 785, 149, 150, 151, 152, 153, - 154, 155, 0, 156, 157, 158, 159, 786, 0, 787, - 0, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 0, 172, 173, 174, 175, 176, 177, 0, 178, + 126, 127, 3, 4, 0, 560, 0, 0, 0, 0, + 565, 129, 130, 0, 131, 132, 133, 567, 135, 136, + 137, 568, 569, 570, 571, 572, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 576, + 577, 155, 0, 156, 157, 158, 159, 579, 0, 581, + 0, 583, 163, 164, 165, 166, 167, 584, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 587, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 589, 190, 191, 590, 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 788, 0, 227, 0, - 228, 229, 230, 231, 0, 232, 0, 233, 234, 0, - 235, 236, 237, 238, 239, 240, 0, 241, 0, 242, - 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 0, 258, 259, 260, - 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 0, 275, 0, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 789, - 0, 287, 288, 289, 290, 0, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 600, 221, 222, 223, 224, 225, 601, 0, 227, 0, + 228, 229, 604, 231, 0, 232, 0, 233, 607, 0, + 609, 236, 237, 610, 611, 240, 0, 241, 0, 614, + 615, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 617, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 620, 621, 268, 269, + 270, 271, 272, 622, 623, 0, 625, 0, 276, 627, + 628, 279, 629, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 632, 289, 633, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 635, 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, 0, 327, 328, 329, 330, 0, 790, 332, - 333, 334, 335, 336, 0, 337, 338, 0, 791, 339, - 340, 341, 0, 0, 342, 343, 344, 345, 346, 347, - 792, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 0, 0, 0, 0, 360, 361, 793, 363, - 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, - 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 315, 316, 317, 318, 319, 636, 637, 638, 323, 324, + 325, 639, 0, 327, 328, 641, 330, 0, 643, 332, + 644, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 650, 651, 346, 652, + 653, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 658, 659, + 364, 365, 660, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 663, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 0, 397, 398, 399, - 400, 401, 402, 403, 794, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 0, 426, - 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 795, - 0, 0, 446, 447, 0, 448, 449, 450, 451, 452, - 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, - 796, 461, 797, 0, 463, 464, 798, 466, 467, 468, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 666, + 400, 401, 402, 667, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 669, 417, + 418, 419, 420, 421, 422, 670, 424, 425, 0, 672, + 427, 428, 673, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 675, 444, 676, + 0, 0, 446, 447, 0, 448, 680, 450, 451, 452, + 453, 454, 0, 455, 682, 683, 0, 0, 458, 459, + 686, 461, 687, 0, 463, 464, 689, 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, - 476, 477, 0, 478, 479, 480, 481, 482, 799, 484, - 0, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 476, 477, 0, 478, 479, 480, 481, 482, 694, 695, + 0, 485, 697, 487, 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 116, 0, 0, 0, + 500, 702, 703, 704, 705, 706, 707, 708, 709, 710, + 711, 712, 512, 513, 514, 515, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 800, 0, 0, 117, 118, 119, 120, 121, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, @@ -392733,7 +399188,7 @@ static const yytype_int16 yytable[] = 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 0, 397, 398, 399, 400, 401, 402, 403, 794, + 396, 0, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, 426, 427, 428, 429, 430, 0, @@ -392748,13 +399203,13 @@ static const yytype_int16 yytable[] = 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 116, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 47, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, 128, 129, 130, 0, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 0, 143, 144, 145, - 146, 147, 148, 0, 785, 149, 150, 151, 152, 153, - 154, 155, 0, 156, 157, 158, 159, 786, 0, 787, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 161, 0, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, @@ -392762,7 +399217,7 @@ static const yytype_int16 yytable[] = 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 788, 0, 227, 0, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, 0, 233, 234, 0, 235, 236, 237, 238, 239, 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, @@ -392774,11 +399229,11 @@ static const yytype_int16 yytable[] = 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, 0, 327, 328, 329, 330, 0, 790, 332, + 325, 326, 0, 327, 328, 329, 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, 344, 345, 346, 347, - 792, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 0, 0, 0, 0, 360, 361, 793, 363, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, @@ -392787,10 +399242,10 @@ static const yytype_int16 yytable[] = 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, 426, 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 795, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 0, 0, 446, 447, 0, 448, 449, 450, 451, 452, 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, - 796, 461, 797, 0, 463, 464, 798, 466, 467, 468, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, 485, 486, 487, 488, 489, 490, 491, 492, 493, @@ -392798,22 +399253,121 @@ static const yytype_int16 yytable[] = 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3300, 0, 0, 117, 118, 119, 120, 121, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 1738, 156, 157, + 158, 159, 160, 0, 0, 1739, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 1740, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 1741, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 1742, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 1743, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 1744, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 1738, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 1740, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 1741, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 2317, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 1743, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 1744, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 3, 4, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 0, 194, 0, 195, 196, 197, 198, 199, 200, 14, - 15, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, - 232, 0, 233, 0, 23, 0, 236, 237, 524, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, @@ -392827,28 +399381,28 @@ static const yytype_int16 yytable[] = 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 27, 28, 29, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 34, 0, 417, 418, 419, 420, 421, 422, - 423, 424, 425, 36, 0, 427, 428, 429, 430, 0, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 526, 444, 445, 38, 0, 446, 447, 39, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, - 472, 473, 41, 474, 475, 476, 477, 0, 478, 479, - 480, 481, 482, 799, 484, 0, 485, 0, 487, 488, - 489, 490, 491, 492, 493, 0, 0, 494, 0, 45, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, - 515, 523, 0, 46, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 47, 0, 0, - 117, 118, 119, 120, 121, 122, 123, 124, 886, 125, + 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 550, 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, @@ -392862,7 +399416,7 @@ static const yytype_int16 yytable[] = 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, - 228, 229, 230, 231, 0, 232, 0, 233, 0, 23, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, @@ -392877,27 +399431,27 @@ static const yytype_int16 yytable[] = 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 27, 28, 29, 0, 360, 361, 362, 0, - 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 551, 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 34, 0, 417, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, - 0, 0, 446, 447, 39, 448, 0, 450, 451, 452, - 453, 454, 0, 455, 887, 457, 0, 0, 888, 459, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, - 469, 470, 0, 0, 471, 472, 473, 41, 474, 475, - 476, 477, 0, 478, 479, 480, 481, 482, 799, 484, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, - 0, 0, 494, 0, 45, 495, 496, 497, 498, 499, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 523, 0, 46, 0, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 47, 0, 0, 117, 118, 119, 120, 121, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, @@ -392912,7 +399466,7 @@ static const yytype_int16 yytable[] = 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, - 232, 0, 233, 0, 23, 0, 236, 237, 524, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, @@ -392924,4736 +399478,3185 @@ static const yytype_int16 yytable[] = 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, - 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 337, 338, 0, 791, 339, 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 27, 28, 29, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 34, 0, 417, 418, 419, 420, 421, 422, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 526, 444, 445, 0, 0, 446, 447, 39, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, - 472, 473, 41, 474, 475, 476, 477, 0, 478, 479, - 480, 481, 482, 799, 484, 0, 485, 0, 487, 488, - 489, 490, 491, 492, 493, 0, 0, 494, 0, 45, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, - 515, 0, 523, 46, 549, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 47, 0, 0, - 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, - 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 129, 130, 0, 131, 132, 133, 0, 135, - 136, 137, 138, 139, 0, 141, 142, 0, 143, 144, - 145, 146, 147, 148, 0, 0, 149, 150, 151, 152, - 153, 154, 155, 0, 156, 157, 158, 159, 160, 0, - 0, 0, 162, 163, 164, 165, 166, 167, 0, 169, - 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, - 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 0, 194, 0, 195, - 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, - 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, - 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 0, 227, - 0, 228, 229, 230, 231, 0, 232, 0, 233, 0, - 0, 0, 236, 237, 524, 0, 240, 0, 241, 0, - 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, - 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, - 260, 261, 262, 263, 264, 0, 265, 0, 267, 268, - 269, 270, 271, 272, 273, 274, 0, 275, 0, 276, - 0, 0, 279, 0, 281, 282, 283, 284, 285, 286, - 0, 0, 287, 0, 289, 0, 0, 291, 292, 293, - 294, 295, 296, 297, 298, 525, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 0, 322, 323, - 324, 325, 326, 0, 327, 328, 0, 330, 0, 331, - 332, 333, 334, 335, 336, 0, 337, 338, 0, 0, - 339, 340, 341, 0, 0, 342, 343, 344, 0, 346, - 0, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 0, 0, 0, 0, 360, 361, 362, - 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, - 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, - 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, - 0, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, - 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 526, 444, - 445, 0, 0, 446, 447, 0, 448, 0, 450, 451, - 452, 453, 454, 0, 455, 456, 457, 0, 0, 458, - 459, 460, 461, 462, 0, 463, 464, 465, 466, 467, - 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, - 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, - 484, 0, 485, 0, 487, 488, 489, 490, 491, 492, - 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, - 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 512, 513, 514, 515, 523, 0, 549, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 985, 0, 0, 117, 118, 119, 120, - 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 129, 130, 0, - 131, 132, 133, 0, 135, 136, 137, 138, 139, 0, - 141, 142, 0, 143, 144, 145, 146, 147, 148, 0, - 0, 149, 150, 151, 152, 153, 154, 155, 0, 156, - 157, 158, 159, 160, 0, 0, 0, 162, 163, 164, - 165, 166, 167, 0, 169, 170, 171, 0, 172, 173, - 174, 175, 176, 177, 0, 0, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, - 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, - 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, - 215, 0, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 0, 227, 0, 228, 229, 230, 231, - 0, 232, 0, 233, 0, 0, 0, 236, 237, 524, - 0, 240, 0, 241, 0, 242, 243, 244, 245, 0, - 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, - 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, - 0, 265, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 0, 275, 0, 276, 0, 0, 279, 0, 281, - 282, 283, 284, 285, 286, 0, 0, 287, 0, 289, - 0, 0, 291, 292, 293, 294, 295, 296, 297, 298, - 525, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 0, 322, 323, 324, 325, 326, 0, 327, - 328, 0, 330, 0, 331, 332, 333, 334, 335, 336, - 0, 337, 338, 0, 0, 339, 340, 341, 0, 0, - 342, 343, 344, 0, 346, 0, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, - 0, 0, 360, 361, 362, 0, 364, 365, 366, 367, - 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, - 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 0, 397, 398, 0, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 0, 0, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 0, 0, 427, 428, 429, 430, - 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 526, 444, 445, 0, 0, 446, 447, - 0, 448, 0, 450, 451, 452, 453, 454, 0, 455, - 456, 457, 0, 0, 458, 459, 460, 461, 462, 0, - 463, 464, 465, 466, 467, 468, 469, 470, 0, 0, - 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 483, 484, 0, 485, 0, 487, - 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, - 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1460, 0, - 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, - 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 129, 130, 0, 131, 132, 133, 0, 135, - 136, 137, 138, 139, 0, 141, 142, 0, 143, 144, - 145, 146, 147, 148, 0, 0, 149, 150, 151, 152, - 153, 154, 155, 0, 156, 157, 158, 159, 160, 0, - 0, 0, 162, 163, 164, 165, 166, 167, 0, 169, - 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, - 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 0, 194, 0, 195, - 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, - 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, - 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 0, 227, - 0, 228, 229, 230, 231, 0, 232, 0, 233, 0, - 0, 0, 236, 237, 524, 0, 240, 0, 241, 0, - 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, - 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, - 260, 261, 262, 263, 264, 0, 265, 0, 267, 268, - 269, 270, 271, 272, 273, 274, 0, 275, 0, 276, - 0, 0, 279, 0, 281, 282, 283, 284, 285, 286, - 0, 0, 287, 0, 289, 0, 0, 291, 292, 293, - 294, 295, 296, 297, 298, 525, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 0, 322, 323, - 324, 325, 326, 0, 327, 328, 0, 330, 0, 331, - 332, 333, 334, 335, 336, 0, 337, 338, 0, 0, - 339, 340, 341, 0, 0, 342, 343, 344, 0, 346, - 0, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 0, 0, 0, 0, 360, 361, 362, - 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, - 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, - 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, - 0, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, - 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 526, 444, - 445, 0, 0, 446, 447, 0, 448, 0, 450, 451, - 452, 453, 454, 0, 455, 456, 457, 0, 0, 458, - 459, 460, 461, 462, 0, 463, 464, 465, 466, 467, - 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, - 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, - 484, 0, 485, 0, 487, 488, 489, 490, 491, 492, - 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, - 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 512, 513, 514, 515, 523, 0, 549, + 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2195, 0, 0, 117, 118, 119, 120, - 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 129, 130, 0, - 131, 132, 133, 0, 135, 136, 137, 138, 139, 0, - 141, 142, 0, 143, 144, 145, 146, 147, 148, 0, - 0, 149, 150, 151, 152, 153, 154, 155, 0, 156, - 157, 158, 159, 160, 0, 0, 0, 162, 163, 164, - 165, 166, 167, 0, 169, 170, 171, 0, 172, 173, - 174, 175, 176, 177, 0, 0, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, - 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, - 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, - 215, 0, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 0, 227, 0, 228, 229, 230, 231, - 0, 232, 0, 233, 0, 0, 0, 236, 237, 524, - 0, 240, 0, 241, 0, 242, 243, 244, 245, 0, - 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, - 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, - 0, 265, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 0, 275, 0, 276, 0, 0, 279, 0, 281, - 282, 283, 284, 285, 286, 0, 0, 287, 0, 289, - 0, 0, 291, 292, 293, 294, 295, 296, 297, 298, - 525, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 0, 322, 323, 324, 325, 326, 0, 327, - 328, 0, 330, 0, 331, 332, 333, 334, 335, 336, - 0, 337, 338, 0, 0, 339, 340, 341, 0, 0, - 342, 343, 344, 0, 346, 0, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, - 0, 0, 360, 361, 362, 0, 364, 365, 366, 367, - 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, - 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 0, 397, 398, 0, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 0, 0, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 0, 0, 427, 428, 429, 430, - 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 526, 444, 445, 0, 0, 446, 447, - 0, 448, 0, 450, 451, 452, 453, 454, 0, 455, - 456, 457, 0, 0, 458, 459, 460, 461, 462, 0, - 463, 464, 465, 466, 467, 468, 469, 470, 0, 0, - 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 483, 484, 0, 485, 0, 487, - 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, - 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2429, 0, - 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, - 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 129, 130, 0, 131, 132, 133, 0, 135, - 136, 137, 138, 139, 0, 141, 142, 0, 143, 144, - 145, 146, 147, 148, 0, 0, 149, 150, 151, 152, - 153, 154, 155, 0, 156, 157, 158, 159, 160, 0, - 0, 0, 162, 163, 164, 165, 166, 167, 0, 169, - 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, - 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 0, 194, 0, 195, - 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, - 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, - 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 0, 227, - 0, 228, 229, 230, 231, 0, 232, 0, 233, 0, - 0, 0, 236, 237, 524, 0, 240, 0, 241, 0, - 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, - 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, - 260, 261, 262, 263, 264, 0, 265, 0, 267, 268, - 269, 270, 271, 272, 273, 274, 0, 275, 0, 276, - 0, 0, 279, 0, 281, 282, 283, 284, 285, 286, - 0, 0, 287, 0, 289, 0, 0, 291, 292, 293, - 294, 295, 296, 297, 298, 525, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 0, 322, 323, - 324, 325, 326, 0, 327, 328, 0, 330, 0, 331, - 332, 333, 334, 335, 336, 0, 337, 338, 0, 0, - 339, 340, 341, 0, 0, 342, 343, 344, 0, 346, - 0, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 0, 0, 0, 0, 360, 361, 362, - 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, - 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, - 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, - 0, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, - 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 526, 444, - 445, 0, 0, 446, 447, 0, 448, 0, 450, 451, - 452, 453, 454, 0, 455, 456, 457, 0, 0, 458, - 459, 460, 461, 462, 0, 463, 464, 465, 466, 467, - 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, - 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, - 484, 0, 485, 0, 487, 488, 489, 490, 491, 492, - 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, - 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 512, 513, 514, 515, 523, 0, 549, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 896, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 791, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2560, 0, 0, 117, 118, 119, 120, - 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 129, 130, 0, - 131, 132, 133, 0, 135, 136, 137, 138, 139, 0, - 141, 142, 0, 143, 144, 145, 146, 147, 148, 0, - 0, 149, 150, 151, 152, 153, 154, 155, 0, 156, - 157, 158, 159, 160, 0, 0, 0, 162, 163, 164, - 165, 166, 167, 0, 169, 170, 171, 0, 172, 173, - 174, 175, 176, 177, 0, 0, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, - 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, - 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, - 215, 0, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 0, 227, 0, 228, 229, 230, 231, - 0, 232, 0, 233, 0, 0, 0, 236, 237, 524, - 0, 240, 0, 241, 0, 242, 243, 244, 245, 0, - 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, - 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, - 0, 265, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 0, 275, 0, 276, 0, 0, 279, 0, 281, - 282, 283, 284, 285, 286, 0, 0, 287, 0, 289, - 0, 0, 291, 292, 293, 294, 295, 296, 297, 298, - 525, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 0, 322, 323, 324, 325, 326, 0, 327, - 328, 0, 330, 0, 331, 332, 333, 334, 335, 336, - 0, 337, 338, 0, 0, 339, 340, 341, 0, 0, - 342, 343, 344, 0, 346, 0, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, - 0, 0, 360, 361, 362, 0, 364, 365, 366, 367, - 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, - 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 0, 397, 398, 0, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 0, 0, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 0, 0, 427, 428, 429, 430, - 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 526, 444, 445, 0, 0, 446, 447, - 0, 448, 0, 450, 451, 452, 453, 454, 0, 455, - 456, 457, 0, 0, 458, 459, 460, 461, 462, 0, - 463, 464, 465, 466, 467, 468, 469, 470, 0, 0, - 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 483, 484, 0, 485, 0, 487, - 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, - 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3206, 0, - 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, - 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 129, 130, 0, 131, 132, 133, 0, 135, - 136, 137, 138, 139, 0, 141, 142, 0, 143, 144, - 145, 146, 147, 148, 0, 0, 149, 150, 151, 152, - 153, 154, 155, 0, 156, 157, 158, 159, 160, 0, - 0, 0, 162, 163, 164, 165, 166, 167, 0, 169, - 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, - 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 0, 194, 0, 195, - 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, - 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, - 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 0, 227, - 0, 228, 229, 230, 231, 0, 232, 0, 233, 0, - 0, 0, 236, 237, 524, 0, 240, 0, 241, 0, - 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, - 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, - 260, 261, 262, 263, 264, 0, 265, 0, 267, 268, - 269, 270, 271, 272, 273, 274, 0, 275, 0, 276, - 0, 0, 279, 0, 281, 282, 283, 284, 285, 286, - 0, 0, 287, 0, 289, 0, 0, 291, 292, 293, - 294, 295, 296, 297, 298, 525, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 0, 322, 323, - 324, 325, 326, 0, 327, 328, 0, 330, 0, 331, - 332, 333, 334, 335, 336, 0, 337, 338, 0, 0, - 339, 340, 341, 0, 0, 342, 343, 344, 0, 346, - 0, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 0, 0, 0, 0, 360, 361, 362, - 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, - 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, - 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, - 0, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, - 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 526, 444, - 445, 0, 0, 446, 447, 0, 448, 0, 450, 451, - 452, 453, 454, 0, 455, 456, 457, 0, 0, 458, - 459, 460, 461, 462, 0, 463, 464, 465, 466, 467, - 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, - 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, - 484, 0, 485, 0, 487, 488, 489, 490, 491, 492, - 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, - 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 512, 513, 514, 515, 523, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 938, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 1942, 0, 0, 0, 0, 1943, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2052, 0, 0, 117, 118, 119, 120, - 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 129, 130, 0, - 131, 132, 133, 0, 135, 136, 137, 138, 139, 0, - 141, 142, 0, 143, 144, 145, 146, 147, 148, 0, - 0, 149, 150, 151, 152, 153, 154, 155, 0, 156, - 157, 158, 159, 160, 0, 0, 0, 162, 163, 164, - 165, 166, 167, 0, 169, 170, 171, 0, 172, 173, - 174, 175, 176, 177, 0, 0, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, - 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, - 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, - 215, 0, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 0, 227, 0, 228, 229, 230, 231, - 0, 232, 0, 233, 0, 0, 0, 236, 237, 524, - 0, 240, 0, 241, 0, 242, 243, 244, 245, 0, - 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, - 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, - 0, 265, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 0, 275, 0, 276, 0, 0, 279, 0, 281, - 282, 283, 284, 285, 286, 0, 0, 287, 0, 289, - 0, 0, 291, 292, 293, 294, 295, 296, 297, 298, - 525, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 0, 322, 323, 324, 325, 326, 0, 327, - 328, 0, 330, 0, 331, 332, 333, 334, 335, 336, - 0, 337, 338, 0, 0, 339, 340, 341, 0, 0, - 342, 343, 344, 0, 346, 0, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, - 0, 0, 360, 361, 362, 0, 364, 365, 366, 367, - 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, - 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 0, 397, 398, 0, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 0, 0, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 0, 0, 427, 428, 429, 430, - 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 526, 444, 445, 0, 0, 446, 447, - 0, 448, 0, 450, 451, 452, 453, 454, 0, 455, - 456, 457, 0, 0, 458, 459, 460, 461, 462, 0, - 463, 464, 465, 466, 467, 468, 469, 470, 0, 0, - 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 483, 484, 0, 485, 0, 487, - 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, - 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2155, 0, - 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, - 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 129, 130, 0, 131, 132, 133, 0, 135, - 136, 137, 138, 139, 0, 141, 142, 0, 143, 144, - 145, 146, 147, 148, 0, 0, 149, 150, 151, 152, - 153, 154, 155, 0, 156, 157, 158, 159, 160, 0, - 0, 0, 162, 163, 164, 165, 166, 167, 0, 169, - 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, - 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 0, 194, 0, 195, - 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, - 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, - 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 0, 227, - 0, 228, 229, 230, 231, 0, 232, 0, 233, 0, - 0, 0, 236, 237, 524, 0, 240, 0, 241, 0, - 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, - 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, - 260, 261, 262, 263, 264, 0, 265, 0, 267, 268, - 269, 270, 271, 272, 273, 274, 0, 275, 0, 276, - 0, 0, 279, 0, 281, 282, 283, 284, 285, 286, - 0, 0, 287, 0, 289, 0, 0, 291, 292, 293, - 294, 295, 296, 297, 298, 525, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 0, 322, 323, - 324, 325, 326, 0, 327, 328, 0, 330, 0, 331, - 332, 333, 334, 335, 336, 0, 337, 338, 0, 0, - 339, 340, 341, 0, 0, 342, 343, 344, 0, 346, - 0, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 0, 0, 0, 0, 360, 361, 362, - 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, - 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, - 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, - 0, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, - 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 526, 444, - 445, 0, 0, 446, 447, 0, 448, 0, 450, 451, - 452, 453, 454, 0, 455, 456, 457, 0, 0, 458, - 459, 460, 461, 462, 0, 463, 464, 465, 466, 467, - 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, - 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, - 484, 0, 485, 0, 487, 488, 489, 490, 491, 492, - 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, - 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 512, 513, 514, 515, 0, 2885, 1339, - 815, 0, 0, 2028, 1046, 0, 0, 0, 0, 0, - 2029, 2030, 0, 3067, 2031, 2032, 2033, 117, 118, 119, - 120, 121, 122, 123, 124, 556, 125, 126, 127, 557, - 558, 559, 2886, 561, 562, 563, 564, 2887, 129, 130, - 566, 131, 132, 133, 2888, 135, 136, 137, 0, 1476, - 2889, 1478, 1479, 573, 143, 144, 145, 146, 147, 148, - 574, 575, 149, 150, 151, 152, 1480, 1481, 155, 578, - 156, 157, 158, 159, 0, 580, 2890, 582, 2891, 163, - 164, 165, 166, 167, 2892, 169, 170, 171, 585, 172, - 173, 174, 175, 176, 177, 586, 2893, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 1486, 190, 191, - 1487, 193, 591, 194, 592, 195, 196, 197, 198, 199, - 200, 593, 594, 201, 202, 203, 204, 595, 596, 205, - 206, 1059, 208, 209, 597, 210, 211, 212, 598, 213, - 214, 215, 599, 216, 217, 218, 219, 0, 221, 222, - 223, 224, 225, 0, 602, 227, 603, 228, 229, 1488, - 231, 605, 232, 606, 233, 2894, 608, 2895, 236, 237, - 2896, 2897, 240, 612, 241, 613, 0, 0, 244, 245, - 616, 246, 247, 248, 249, 250, 251, 252, 2898, 254, - 255, 256, 257, 618, 258, 259, 260, 261, 262, 263, - 264, 619, 265, 2899, 0, 268, 269, 270, 271, 272, - 1494, 1495, 624, 1496, 626, 276, 2900, 2901, 279, 2902, - 281, 282, 283, 284, 285, 286, 630, 631, 287, 2903, - 289, 2904, 634, 291, 292, 293, 294, 295, 296, 297, - 298, 2905, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 1503, 2906, 1505, 323, 324, 325, 2907, 640, - 327, 328, 2908, 330, 642, 0, 332, 1507, 334, 335, - 336, 645, 337, 338, 646, 647, 2909, 340, 341, 648, - 649, 342, 343, 0, 2910, 346, 2911, 0, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 654, - 655, 656, 657, 360, 361, 0, 2912, 364, 365, 0, - 367, 368, 369, 661, 370, 371, 372, 373, 374, 375, - 662, 376, 377, 378, 1511, 380, 381, 382, 383, 664, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 665, 397, 398, 2913, 400, 401, 402, - 1513, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 668, 2914, 417, 418, 419, 420, - 421, 422, 2915, 424, 425, 671, 2916, 427, 428, 1517, - 430, 674, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 2917, 444, 0, 677, 678, 446, - 447, 679, 448, 2918, 450, 451, 452, 453, 454, 681, - 455, 1520, 1521, 684, 685, 458, 459, 0, 461, 0, - 688, 463, 464, 2919, 466, 467, 468, 469, 470, 2920, - 691, 471, 472, 473, 692, 474, 475, 476, 477, 693, - 478, 479, 480, 481, 482, 0, 1524, 696, 485, 2921, - 487, 488, 489, 490, 491, 492, 493, 698, 699, 494, - 700, 701, 495, 496, 497, 498, 499, 500, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 512, - 513, 514, 515, 0, 523, 0, 2034, 2035, 2036, 2028, - 2922, 2923, 2039, 2040, 2041, 2042, 2029, 2030, 0, 0, - 2031, 2032, 2033, 117, 118, 119, 120, 121, 122, 123, - 124, 0, 125, 126, 127, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 129, 130, 0, 131, 132, 133, - 0, 135, 136, 137, 138, 139, 0, 141, 142, 0, - 143, 144, 145, 146, 147, 148, 0, 0, 149, 150, - 151, 152, 153, 154, 155, 0, 156, 157, 158, 159, - 160, 0, 0, 0, 162, 163, 164, 165, 166, 167, - 0, 169, 170, 171, 0, 172, 173, 174, 175, 176, - 177, 0, 0, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 0, 194, - 0, 195, 196, 197, 198, 199, 200, 0, 0, 201, - 202, 203, 204, 0, 0, 205, 206, 207, 208, 209, - 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 0, 227, 0, 228, 229, 230, 231, 0, 232, 0, - 233, 0, 0, 0, 236, 237, 524, 0, 240, 0, - 241, 0, 242, 243, 244, 245, 0, 246, 247, 248, - 249, 250, 251, 252, 0, 254, 255, 256, 257, 0, - 258, 259, 260, 261, 262, 263, 264, 0, 265, 0, - 267, 268, 269, 270, 271, 272, 273, 274, 0, 275, - 0, 276, 0, 0, 279, 0, 281, 282, 283, 284, - 285, 286, 0, 0, 287, 0, 289, 0, 0, 291, - 292, 293, 294, 295, 296, 297, 298, 525, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 0, - 322, 323, 324, 325, 326, 0, 327, 328, 0, 330, - 0, 331, 332, 333, 334, 335, 336, 0, 337, 338, - 0, 0, 339, 340, 341, 0, 0, 342, 343, 344, - 0, 346, 0, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 0, 0, 0, 0, 360, - 361, 362, 0, 364, 365, 366, 367, 368, 369, 0, - 370, 371, 372, 373, 374, 375, 0, 376, 377, 378, - 379, 380, 381, 382, 383, 0, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 0, - 397, 398, 0, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 0, 0, 427, 428, 429, 430, 0, 431, 432, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 526, 444, 445, 0, 0, 446, 447, 0, 448, 0, - 450, 451, 452, 453, 454, 0, 455, 456, 457, 0, - 0, 458, 459, 460, 461, 462, 0, 463, 464, 465, - 466, 467, 468, 469, 470, 0, 0, 471, 472, 473, - 0, 474, 475, 476, 477, 0, 478, 479, 480, 481, - 482, 483, 484, 0, 485, 0, 487, 488, 489, 490, - 491, 492, 493, 0, 0, 494, 0, 0, 495, 496, - 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 512, 513, 514, 515, 0, - 0, 0, 2034, 2035, 2036, 0, 2037, 2038, 2039, 2040, - 2041, 2042, 1607, 0, 0, 1608, 0, 0, 0, 1609, - 1610, 1611, 1612, 1613, 1614, 1615, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1616, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1618, 1607, 0, 0, 1608, 0, 0, 1619, 1609, 1610, - 1611, 1612, 1613, 1614, 1615, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1616, - 0, 0, 0, 0, 1620, 0, 0, 0, 0, 1618, - 1607, 0, 0, 1608, 0, 0, 1619, 1609, 1610, 1611, - 1612, 1613, 1614, 1615, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1616, 0, - 0, 0, 0, 1620, 0, 0, 0, 0, 1618, 0, - 0, 0, 0, 0, 0, 1619, 0, 1607, 0, 0, - 1608, 0, 0, 0, 1609, 1610, 1611, 1612, 1613, 1614, - 1615, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1620, 0, 0, 1616, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1618, 1607, 0, 0, 1608, - 1621, 0, 1619, 1609, 1610, 1611, 1612, 1613, 1614, 1615, - 0, 0, 0, 0, 0, 0, 0, 1622, 0, 0, - 0, 0, 1623, 0, 1616, 0, 0, 0, 0, 1620, - 0, 0, 0, 0, 1618, 0, 0, 0, 0, 1621, - 0, 1619, 0, 0, 0, 1624, 1625, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1622, 0, 0, 0, - 1626, 1623, 0, 0, 0, 0, 0, 0, 1620, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1621, 0, - 0, 0, 0, 0, 1624, 1625, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1622, 0, 0, 1627, 1626, - 1623, 1628, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1629, 0, 0, 1630, 0, - 0, 0, 0, 1624, 1625, 1621, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1627, 1626, 0, - 1628, 0, 1622, 0, 0, 0, 0, 1623, 0, 0, - 0, 0, 0, 0, 1629, 0, 0, 1630, 0, 0, - 0, 0, 0, 0, 1621, 0, 0, 0, 0, 0, - 1624, 1625, 0, 0, 0, 0, 1627, 0, 0, 1628, - 0, 1622, 0, 0, 0, 1626, 1623, 0, 0, 0, - 0, 0, 0, 1629, 0, 0, 1630, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1624, - 1625, 0, 0, 0, 0, 1631, 0, 0, 0, 0, - 0, 0, 0, 1627, 1626, 0, 1628, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1629, 0, 0, 1630, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1631, 0, 0, 0, 0, 0, - 0, 0, 1627, 0, 0, 1628, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1629, - 0, 0, 1630, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1631, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1632, 0, 0, 1633, 1634, 1635, 0, 1636, - 1637, 1638, 1639, 1640, 1641, 0, 0, 0, 0, 2692, - 1631, 0, 0, 0, 0, 0, 1607, 0, 0, 1608, - 0, 0, 0, 1609, 1610, 1611, 1612, 1613, 1614, 1615, - 0, 1632, 0, 0, 1633, 1634, 1635, 0, 1636, 1637, - 1638, 1639, 1640, 1641, 1616, 0, 0, 0, 2764, 1631, - 0, 0, 0, 0, 1618, 0, 0, 0, 0, 0, - 0, 1619, 0, 0, 0, 0, 0, 0, 0, 0, - 1632, 0, 0, 1633, 1634, 1635, 0, 1636, 1637, 1638, - 1639, 1640, 1641, 0, 0, 0, 0, 2831, 1620, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1607, 0, 0, 1608, 0, 0, 0, 1609, - 1610, 1611, 1612, 1613, 1614, 1615, 0, 1632, 0, 0, - 1633, 1634, 1635, 0, 1636, 1637, 1638, 1639, 1640, 1641, - 1616, 0, 0, 0, 3059, 0, 0, 0, 0, 0, - 1618, 1607, 0, 0, 1608, 0, 0, 1619, 1609, 1610, - 1611, 1612, 1613, 1614, 1615, 0, 1632, 0, 0, 1633, - 1634, 1635, 0, 1636, 1637, 1638, 1639, 1640, 1641, 1616, - 0, 0, 0, 3066, 1620, 0, 0, 0, 0, 1618, - 1607, 0, 0, 1608, 1621, 0, 1619, 1609, 1610, 1611, - 1612, 1613, 1614, 1615, 0, 0, 0, 0, 0, 0, - 0, 1622, 0, 0, 0, 0, 1623, 0, 1616, 0, - 0, 0, 0, 1620, 0, 0, 0, 0, 1618, 0, - 0, 0, 0, 0, 0, 1619, 0, 0, 0, 1624, - 1625, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1626, 0, 0, 0, 0, 0, - 0, 0, 1620, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1607, 0, 0, 1608, - 1621, 0, 0, 1609, 1610, 1611, 1612, 1613, 1614, 1615, - 0, 0, 1627, 0, 0, 1628, 0, 1622, 0, 0, - 0, 0, 1623, 0, 1616, 0, 0, 0, 0, 1629, - 0, 0, 1630, 0, 1618, 0, 0, 0, 0, 1621, - 0, 1619, 0, 0, 0, 1624, 1625, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1622, 0, 0, 0, - 1626, 1623, 0, 0, 0, 0, 0, 0, 1620, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1621, 0, - 0, 0, 0, 0, 1624, 1625, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1622, 0, 0, 1627, 1626, - 1623, 1628, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1629, 0, 0, 1630, 0, - 0, 0, 0, 1624, 1625, 0, 0, 0, 0, 1631, - 0, 0, 0, 0, 0, 0, 0, 1627, 1626, 0, - 1628, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1629, 0, 0, 1630, 0, 0, - 0, 0, 0, 0, 1621, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1627, 0, 0, 1628, - 0, 1622, 0, 0, 0, 0, 1623, 0, 0, 0, - 0, 0, 0, 1629, 0, 0, 1630, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1624, - 1625, 0, 0, 0, 0, 1631, 0, 0, 0, 0, - 0, 0, 0, 0, 1626, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1632, 0, 0, 1633, - 1634, 1635, 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, - 0, 0, 0, 3227, 1631, 0, 0, 0, 0, 0, - 0, 0, 1627, 0, 1607, 1628, 0, 1608, 0, 0, - 0, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 0, 1629, - 0, 0, 1630, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1616, 1631, 0, 0, 0, 0, 0, 0, - 0, 0, 1618, 0, 0, 0, 0, 0, 0, 1619, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1632, 0, 0, 1633, 1634, 1635, 0, 1636, - 1637, 1638, 1639, 1640, 1641, 0, 1620, 0, 0, 3249, - 0, 0, 0, 0, 0, 0, 1607, 0, 0, 1608, - 0, 0, 0, 1609, 1610, 1611, 1612, 1613, 1614, 1615, - 0, 1632, 0, 0, 1633, 1634, 1635, 0, 1636, 1637, - 1638, 1639, 1640, 1641, 1616, 0, 0, 0, 3351, 1631, - 0, 0, 0, 0, 1618, 1607, 0, 0, 1608, 0, - 0, 1619, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 0, - 1632, 0, 0, 1633, 1634, 1635, 0, 1636, 1637, 1638, - 1639, 1640, 1641, 1616, 0, 0, 0, 3409, 1620, 0, - 0, 0, 0, 1618, 0, 0, 0, 0, 0, 0, - 1619, 0, 1621, 0, 0, 1607, 0, 0, 1608, 0, - 0, 0, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1622, - 0, 0, 0, 0, 1623, 0, 0, 1620, 0, 0, - 0, 0, 0, 1616, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1618, 0, 0, 0, 1624, 1625, 0, - 1619, 0, 0, 0, 0, 0, 1632, 0, 0, 1633, - 1634, 1635, 1626, 1636, 1637, 1638, 1639, 1640, 1641, 0, - 0, 0, 0, 3431, 0, 0, 0, 1620, 0, 0, - 0, 0, 0, 0, 1621, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1627, 1622, 0, 1628, 0, 0, 1623, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1629, 0, 0, - 1630, 0, 0, 1621, 0, 0, 0, 0, 0, 1624, - 1625, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1622, 0, 0, 0, 1626, 1623, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1624, 1625, - 0, 0, 0, 1621, 0, 0, 0, 0, 0, 0, - 0, 0, 1627, 1626, 0, 1628, 0, 0, 0, 0, - 1622, 0, 0, 0, 0, 1623, 0, 0, 0, 1629, - 0, 0, 1630, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1631, 1624, 1625, - 0, 1627, 0, 0, 1628, 0, 0, 0, 0, 0, - 0, 0, 0, 1626, 0, 0, 0, 0, 1629, 0, - 0, 1630, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1627, 0, 0, 1628, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1629, 0, - 0, 1630, 0, 0, 0, 0, 0, 0, 0, 1631, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1632, 0, 0, 1633, 1634, 1635, - 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, 1631, 1792, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1631, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1632, 0, 0, 1633, - 1634, 1635, 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, - 0, 2785, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1632, 0, 0, 1633, 1634, - 1635, 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, 0, - 3217, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 555, 0, 0, 1632, 0, 0, 1633, 1634, - 1635, 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, 0, - 3393, 117, 118, 119, 120, 121, 122, 123, 124, 556, - 125, 126, 127, 557, 558, 559, 560, 561, 562, 563, - 564, 565, 129, 130, 566, 131, 132, 133, 567, 135, - 136, 137, 568, 569, 570, 571, 572, 573, 143, 144, - 145, 146, 147, 148, 574, 575, 149, 150, 151, 152, - 576, 577, 155, 578, 156, 157, 158, 159, 579, 580, - 581, 582, 583, 163, 164, 165, 166, 167, 584, 169, - 170, 171, 585, 172, 173, 174, 175, 176, 177, 586, - 587, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 589, 190, 191, 590, 193, 591, 194, 592, 195, - 196, 197, 198, 199, 200, 593, 594, 201, 202, 203, - 204, 595, 596, 205, 206, 207, 208, 209, 597, 210, - 211, 212, 598, 213, 214, 215, 599, 216, 217, 218, - 219, 600, 221, 222, 223, 224, 225, 601, 602, 227, - 603, 228, 229, 604, 231, 605, 232, 606, 233, 607, - 608, 609, 236, 237, 610, 611, 240, 612, 241, 613, - 614, 615, 244, 245, 616, 246, 247, 248, 249, 250, - 251, 252, 617, 254, 255, 256, 257, 618, 258, 259, - 260, 261, 262, 263, 264, 619, 265, 620, 621, 268, - 269, 270, 271, 272, 622, 623, 624, 625, 626, 276, - 627, 628, 279, 629, 281, 282, 283, 284, 285, 286, - 630, 631, 287, 632, 289, 633, 634, 291, 292, 293, - 294, 295, 296, 297, 298, 635, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 636, 637, 638, 323, - 324, 325, 639, 640, 327, 328, 641, 330, 642, 643, - 332, 644, 334, 335, 336, 645, 337, 338, 646, 647, - 339, 340, 341, 648, 649, 342, 343, 650, 651, 346, - 652, 653, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 654, 655, 656, 657, 360, 361, 658, - 659, 364, 365, 660, 367, 368, 369, 661, 370, 371, - 372, 373, 374, 375, 662, 376, 377, 378, 663, 380, - 381, 382, 383, 664, 384, 385, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 396, 665, 397, 398, - 666, 400, 401, 402, 667, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 668, 669, - 417, 418, 419, 420, 421, 422, 670, 424, 425, 671, - 672, 427, 428, 673, 430, 674, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 675, 444, - 676, 677, 678, 446, 447, 679, 448, 680, 450, 451, - 452, 453, 454, 681, 455, 682, 683, 684, 685, 458, - 459, 686, 461, 687, 688, 463, 464, 689, 466, 467, - 468, 469, 470, 690, 691, 471, 472, 473, 692, 474, - 475, 476, 477, 693, 478, 479, 480, 481, 482, 694, - 695, 696, 485, 697, 487, 488, 489, 490, 491, 492, - 493, 698, 699, 494, 700, 701, 495, 496, 497, 498, - 499, 500, 702, 703, 704, 705, 706, 707, 708, 709, - 710, 711, 712, 512, 513, 514, 515, 523, 0, 0, - 0, 0, 0, 0, 0, 0, 2063, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, - 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 129, 130, 0, - 131, 132, 133, 0, 135, 136, 137, 138, 139, 0, - 141, 142, 0, 143, 144, 145, 146, 147, 148, 0, - 0, 149, 150, 151, 152, 153, 154, 155, 0, 156, - 157, 158, 159, 160, 0, 0, 0, 162, 163, 164, - 165, 166, 167, 0, 169, 170, 171, 0, 172, 173, - 174, 175, 176, 177, 0, 0, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, - 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, - 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, - 215, 0, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 0, 227, 0, 228, 229, 230, 231, - 0, 232, 0, 233, 0, 0, 0, 236, 237, 524, - 0, 240, 0, 241, 0, 242, 243, 244, 245, 0, - 246, 247, 248, 249, 250, 251, 252, 0, 254, 255, - 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, - 0, 265, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 0, 275, 0, 276, 0, 0, 279, 0, 281, - 282, 283, 284, 285, 286, 0, 0, 287, 0, 289, - 0, 0, 291, 292, 293, 294, 295, 296, 297, 298, - 525, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 0, 322, 323, 324, 325, 326, 0, 327, - 328, 0, 330, 0, 331, 332, 333, 334, 335, 336, - 0, 337, 338, 0, 0, 339, 340, 341, 0, 0, - 342, 343, 344, 0, 346, 0, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, - 0, 0, 360, 361, 362, 0, 364, 365, 366, 367, - 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, - 376, 377, 378, 379, 380, 381, 382, 383, 0, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 0, 397, 398, 0, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 0, 0, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 0, 0, 427, 428, 429, 430, - 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 526, 444, 445, 0, 0, 446, 447, - 0, 448, 0, 450, 451, 452, 453, 454, 0, 455, - 456, 457, 0, 0, 458, 459, 460, 461, 462, 0, - 463, 464, 465, 466, 467, 468, 469, 470, 0, 0, - 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 483, 484, 0, 485, 0, 487, - 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, - 0, 495, 496, 497, 498, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, - 0, 2685, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 117, 118, 119, 120, 121, 122, 123, 124, 0, - 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 129, 130, 0, 131, 132, 133, 0, 135, - 136, 137, 138, 139, 0, 141, 142, 0, 143, 144, - 145, 146, 147, 148, 0, 0, 149, 150, 151, 152, - 153, 154, 155, 0, 156, 157, 158, 159, 160, 0, - 0, 0, 162, 163, 164, 165, 166, 167, 0, 169, - 170, 171, 0, 172, 173, 174, 175, 176, 177, 0, - 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 0, 194, 0, 195, - 196, 197, 198, 199, 200, 0, 0, 201, 202, 203, - 204, 0, 0, 205, 206, 207, 208, 209, 0, 210, - 211, 212, 0, 213, 214, 215, 0, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 0, 227, - 0, 228, 229, 230, 231, 0, 232, 0, 233, 0, - 0, 0, 236, 237, 524, 0, 240, 0, 241, 0, - 242, 243, 244, 245, 0, 246, 247, 248, 249, 250, - 251, 252, 0, 254, 255, 256, 257, 0, 258, 259, - 260, 261, 262, 263, 264, 0, 265, 0, 267, 268, - 269, 270, 271, 272, 273, 274, 0, 275, 0, 276, - 0, 0, 279, 0, 281, 282, 283, 284, 285, 286, - 0, 0, 287, 0, 289, 0, 0, 291, 292, 293, - 294, 295, 296, 297, 298, 525, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 0, 322, 323, - 324, 325, 326, 0, 327, 328, 0, 330, 0, 331, - 332, 333, 334, 335, 336, 0, 337, 338, 0, 0, - 339, 340, 341, 0, 0, 342, 343, 344, 0, 346, - 0, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 0, 0, 0, 0, 360, 361, 362, - 0, 364, 365, 366, 367, 368, 369, 0, 370, 371, - 372, 373, 374, 375, 0, 376, 377, 378, 379, 380, - 381, 382, 383, 0, 384, 385, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 396, 0, 397, 398, - 0, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 0, 0, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 0, - 0, 427, 428, 429, 430, 0, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 526, 444, - 445, 0, 0, 446, 447, 0, 448, 0, 450, 451, - 452, 453, 454, 0, 455, 456, 457, 0, 0, 458, - 459, 460, 461, 462, 0, 463, 464, 465, 466, 467, - 468, 469, 470, 0, 0, 471, 472, 473, 0, 474, - 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, - 484, 0, 485, 0, 487, 488, 489, 490, 491, 492, - 493, 0, 0, 494, 0, 0, 495, 496, 497, 498, - 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 512, 513, 514, 515, 964, 1339, 815, - 0, 0, 0, 1046, 0, 0, 2688, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, - 121, 122, 123, 124, 0, 125, 126, 127, 0, 0, - 0, 560, 0, 0, 0, 0, 565, 129, 130, 0, - 131, 132, 133, 567, 135, 136, 137, 568, 569, 570, - 571, 572, 0, 143, 144, 145, 146, 147, 148, 0, - 0, 149, 150, 151, 152, 576, 577, 155, 0, 156, - 157, 158, 159, 579, 0, 581, 0, 583, 163, 164, - 165, 166, 167, 584, 169, 170, 171, 0, 172, 173, - 174, 175, 176, 177, 0, 587, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 589, 190, 191, 590, - 193, 0, 194, 0, 195, 196, 197, 198, 199, 200, - 0, 0, 201, 202, 203, 204, 0, 0, 205, 206, - 207, 208, 209, 0, 210, 211, 212, 0, 213, 214, - 215, 0, 216, 217, 218, 219, 600, 221, 222, 223, - 224, 225, 601, 1340, 227, 0, 228, 229, 604, 231, - 0, 232, 0, 233, 607, 0, 609, 236, 237, 610, - 611, 240, 0, 241, 0, 614, 615, 244, 245, 0, - 246, 247, 248, 249, 250, 251, 252, 617, 254, 255, - 256, 257, 0, 258, 259, 260, 261, 262, 263, 264, - 0, 265, 620, 621, 268, 269, 270, 271, 272, 622, - 623, 0, 625, 0, 276, 627, 628, 279, 629, 281, - 282, 283, 284, 285, 286, 0, 0, 287, 632, 289, - 633, 0, 291, 292, 293, 294, 295, 296, 297, 298, - 635, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 636, 637, 638, 323, 324, 325, 639, 0, 327, - 328, 641, 330, 0, 643, 332, 644, 334, 335, 336, - 0, 337, 338, 1341, 0, 339, 340, 341, 0, 0, - 342, 343, 650, 651, 346, 652, 653, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 0, 0, - 0, 0, 360, 361, 658, 659, 364, 365, 660, 367, - 368, 369, 0, 370, 371, 372, 373, 374, 375, 0, - 376, 377, 378, 663, 380, 381, 382, 383, 0, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 0, 397, 398, 666, 400, 401, 402, 667, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 0, 669, 417, 418, 419, 420, 421, - 422, 670, 424, 425, 0, 672, 427, 428, 673, 430, - 0, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 675, 444, 676, 0, 0, 446, 447, - 0, 448, 680, 450, 451, 452, 453, 454, 0, 455, - 682, 683, 0, 0, 458, 459, 686, 461, 687, 1342, - 463, 464, 689, 466, 467, 468, 469, 470, 0, 0, - 471, 472, 473, 0, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 694, 695, 0, 485, 697, 487, - 488, 489, 490, 491, 492, 493, 0, 0, 494, 0, - 0, 495, 496, 497, 498, 499, 500, 702, 703, 704, - 705, 706, 707, 708, 709, 710, 711, 712, 512, 513, - 514, 515, 0, 0, 1607, 0, 0, 1608, 0, 1343, - 1344, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1616, 0, 0, 0, 0, 2161, 0, 0, - 0, 0, 1618, 1607, 0, 0, 1608, 0, 0, 1619, - 1609, 1610, 1611, 1612, 1613, 1614, 1615, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 1950, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 1951, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 1952, + 448, 0, 450, 1953, 452, 1954, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 1955, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1616, 0, 0, 0, 0, 1620, 0, 0, 0, - 0, 1618, 1607, 0, 0, 1608, 0, 0, 1619, 1609, - 1610, 1611, 1612, 1613, 1614, 1615, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 815, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1616, 0, 0, 0, 0, 1620, 0, 0, 0, 0, - 1618, 0, 2162, 0, 0, 0, 0, 1619, 0, 0, - 1607, 0, 0, 1608, 0, 0, 0, 1609, 1610, 1611, - 1612, 1613, 1614, 1615, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1620, 0, 0, 0, 1616, 0, - 0, 0, 1886, 0, 0, 0, 0, 0, 1618, 0, - 1607, 0, 1621, 1608, 0, 1619, 0, 1609, 1610, 1611, - 1612, 1613, 1614, 1615, 0, 0, 0, 0, 0, 1622, - 0, 0, 0, 0, 1623, 0, 0, 0, 1616, 0, - 0, 1922, 1620, 0, 0, 0, 1923, 0, 1618, 0, - 0, 1621, 0, 0, 0, 1619, 0, 1624, 1625, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1622, 0, - 0, 0, 1626, 1623, 0, 0, 0, 0, 0, 3500, - 0, 0, 1620, 0, 0, 0, 0, 0, 0, 0, - 1621, 0, 0, 0, 0, 0, 1624, 1625, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1622, 0, 0, - 1627, 1626, 1623, 1628, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1629, 0, 0, - 1630, 0, 0, 0, 0, 1624, 1625, 0, 1621, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1627, - 1626, 0, 1628, 0, 0, 1622, 0, 0, 0, 0, - 1623, 0, 0, 0, 0, 0, 1629, 0, 0, 1630, - 0, 0, 0, 0, 0, 0, 0, 0, 1621, 0, - 0, 0, 0, 1624, 1625, 0, 0, 0, 1627, 0, - 0, 1628, 0, 0, 0, 1622, 0, 0, 1626, 0, - 1623, 0, 0, 0, 0, 1629, 0, 0, 1630, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1624, 1625, 0, 0, 1631, 0, 0, - 0, 0, 0, 0, 0, 0, 1627, 3501, 1626, 1628, + 117, 118, 119, 120, 121, 122, 123, 124, 822, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 823, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 824, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 825, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 826, 457, 0, 0, 827, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1629, 0, 0, 1630, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1631, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1627, 0, 0, 1628, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 859, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2165, 0, 0, 1629, 0, 0, 1630, 0, 0, 0, - 0, 0, 0, 0, 0, 1631, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1893, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 891, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1632, 0, 0, 1633, 1634, 1635, - 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, 0, 0, - 0, 0, 0, 1631, 0, 0, 0, 0, 1607, 0, - 0, 1608, 0, 0, 0, 1609, 1610, 1611, 1612, 1613, - 1614, 1615, 0, 1632, 0, 0, 1633, 1634, 1635, 0, - 1636, 1637, 1638, 1639, 1640, 1641, 1616, 0, 0, 0, - 1928, 0, 0, 1631, 0, 0, 1618, 0, 0, 0, - 0, 0, 0, 1619, 0, 0, 0, 0, 0, 0, - 0, 0, 1632, 0, 0, 1633, 1634, 1635, 0, 1636, - 1637, 1638, 1639, 1640, 1641, 0, 0, 0, 0, 0, - 1620, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1607, 0, 0, 1608, 0, - 0, 0, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 0, - 1632, 0, 0, 1633, 1634, 1635, 0, 1636, 1637, 1638, - 1639, 1640, 1641, 1616, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1618, 0, 0, 0, 0, 0, 0, - 1619, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1632, 0, 0, 1633, 1634, 1635, 0, 1636, 1637, 1638, - 1639, 1640, 1641, 0, 0, 0, 0, 1620, 0, 0, - 0, 0, 1607, 0, 0, 1608, 1621, 0, 0, 1609, - 1610, 1611, 1612, 1613, 1614, 1615, 0, 0, 0, 0, - 0, 0, 0, 1622, 0, 0, 0, 0, 1623, 0, - 1616, 0, 0, 0, 1935, 0, 0, 0, 0, 0, - 1618, 0, 0, 0, 0, 0, 0, 1619, 0, 0, - 0, 1624, 1625, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1626, 0, 0, 0, - 0, 0, 0, 0, 1620, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1933, 1607, - 0, 0, 1608, 1621, 0, 0, 1609, 1610, 1611, 1612, - 1613, 1614, 1615, 0, 1627, 0, 0, 1628, 0, 0, - 1622, 0, 0, 0, 0, 1623, 0, 1616, 0, 0, - 0, 1629, 0, 0, 1630, 0, 0, 1618, 0, 0, - 0, 0, 0, 0, 1619, 0, 0, 0, 1624, 1625, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 894, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1626, 0, 0, 0, 0, 0, 0, - 0, 1620, 0, 0, 0, 0, 0, 0, 0, 0, - 1621, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1622, 0, 0, - 0, 1627, 1623, 0, 1628, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1629, 0, - 0, 1630, 0, 0, 0, 1624, 1625, 0, 0, 0, - 0, 1631, 0, 0, 1607, 0, 0, 1608, 0, 0, - 1626, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2056, 0, 0, - 0, 0, 1616, 0, 0, 0, 0, 1621, 0, 0, - 0, 0, 1618, 0, 0, 0, 0, 0, 1627, 1619, - 0, 1628, 0, 0, 1622, 0, 0, 0, 0, 1623, - 0, 0, 0, 0, 0, 1629, 0, 0, 1630, 0, - 0, 0, 0, 0, 0, 0, 1620, 0, 0, 0, - 0, 0, 1624, 1625, 0, 0, 0, 0, 1631, 0, - 0, 0, 0, 0, 0, 0, 0, 1626, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1632, 0, - 0, 1633, 1634, 1635, 0, 1636, 1637, 1638, 1639, 1640, - 1641, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1627, 0, 0, 1628, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 898, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1629, 0, 0, 1630, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1631, 0, 0, 0, 0, - 0, 0, 1621, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1622, - 0, 0, 0, 0, 1623, 1632, 0, 0, 1633, 1634, - 1635, 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1624, 1625, 0, - 0, 0, 0, 0, 0, 0, 1607, 0, 0, 1608, - 0, 0, 1626, 1609, 1610, 1611, 1612, 1613, 1614, 1615, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 926, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1631, 0, 1616, 0, 0, 0, 2762, 0, - 0, 0, 0, 0, 1618, 0, 0, 0, 0, 0, - 1627, 1619, 1632, 1628, 0, 1633, 1634, 1635, 0, 1636, - 1637, 1638, 1639, 1640, 1641, 0, 0, 1629, 0, 0, - 1630, 0, 0, 0, 0, 0, 0, 0, 1620, 0, - 1607, 0, 0, 1608, 0, 0, 0, 1609, 1610, 1611, - 1612, 1613, 1614, 1615, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1616, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1618, 0, - 0, 0, 0, 0, 0, 1619, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1632, - 0, 0, 1633, 1634, 1635, 0, 1636, 1637, 1638, 1639, - 1640, 1641, 1620, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1631, 0, 1607, - 0, 0, 1608, 0, 1621, 0, 1609, 1610, 1611, 1612, - 1613, 1614, 1615, 0, 0, 0, 0, 0, 0, 0, - 0, 1622, 0, 0, 0, 0, 1623, 1616, 0, 0, - 2749, 0, 0, 0, 0, 0, 0, 1618, 0, 0, - 0, 0, 0, 0, 1619, 0, 0, 0, 0, 1624, - 1625, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1626, 0, 0, 0, 0, 0, - 0, 1620, 0, 0, 0, 0, 0, 0, 1621, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 954, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1622, 0, 0, 0, 0, - 1623, 0, 1627, 0, 1632, 1628, 0, 1633, 1634, 1635, - 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, 0, 1629, - 0, 0, 1630, 1624, 1625, 0, 0, 0, 0, 0, - 0, 0, 1607, 0, 0, 1608, 0, 0, 1626, 1609, - 1610, 1611, 1612, 1613, 1614, 1615, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 957, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1616, 0, 0, 0, 0, 0, 0, 1621, 0, 0, - 1618, 0, 0, 0, 0, 0, 1627, 1619, 0, 1628, - 0, 0, 0, 0, 1622, 0, 0, 0, 0, 1623, - 0, 0, 0, 1629, 0, 0, 1630, 0, 0, 0, - 0, 0, 0, 0, 1620, 0, 0, 0, 0, 0, - 0, 0, 1802, 1625, 0, 0, 0, 0, 0, 1631, - 0, 0, 0, 0, 0, 0, 0, 1626, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1607, 0, - 0, 1608, 0, 0, 0, 1609, 1610, 0, 0, 1613, - 1614, 1615, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1627, 1616, 0, 1628, 0, - 0, 0, 0, 0, 0, 0, 1618, 0, 0, 0, - 0, 0, 1629, 1619, 0, 1630, 0, 0, 0, 0, - 0, 0, 0, 1631, 1607, 0, 0, 1608, 0, 0, - 1621, 1609, 1610, 0, 0, -2041, -2041, -2041, 0, 0, - 1620, 0, 0, 0, 0, 0, 0, 1622, 0, 0, - 0, 0, 1623, 0, 0, 0, 1632, 0, 0, 1633, - 1634, 1635, 1618, 1636, 1637, 1638, 1639, 1640, 1641, 1619, - 0, 1607, 0, 0, 1608, 1624, 1625, 0, 1609, 1610, - 0, 0, 1613, 1614, 1615, 0, 0, 0, 0, 0, - 1626, 0, 0, 0, 0, 0, 1620, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1618, - 0, 1607, 1631, 0, 1608, 0, 1619, 0, 1609, 1610, - 0, 0, 1613, 1614, 1615, 0, 0, 0, 1627, 0, - 1632, 1628, 0, 1633, 1634, 1635, 1621, 1636, 1637, 1638, - 1639, 1640, 1641, 1620, 0, 1629, 0, 0, 1630, 1618, - 0, 0, 0, 1622, 0, 0, 1619, 0, 1623, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 1000, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 1023, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1624, 1625, 1620, 0, 0, 0, 0, 0, 0, - 0, 0, 1621, 0, 0, 0, 1626, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1622, - 0, 0, 0, 0, 1623, 0, 0, 0, 0, 1632, - 0, 0, 1633, 1634, 1635, 0, 1636, 1637, 1638, 1639, - 1640, 1641, 0, 0, 1627, 0, 0, 1628, 0, 1621, - 0, 0, 0, 0, 0, 1631, 0, 0, 0, 0, - 0, 1629, 1626, 0, 1630, 0, 1622, 0, 0, 0, - 0, 1623, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1621, - 0, 0, 0, 0, 1624, 1625, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1622, 0, 0, 1626, - 0, 1623, 0, 0, 0, 0, 0, 1629, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 822, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 826, 457, 0, 0, 827, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, -2041, -2041, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1627, 0, 1626, - 1628, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1631, 1632, 0, 1629, 1633, 1634, 1635, 0, 1636, - 1637, 1638, 1639, 2182, 1641, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 1302, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - -2041, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1629, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1631, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 1304, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 1307, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 1309, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 2228, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 1475, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1631, 0, 0, 0, 1632, 0, - 0, 1633, 1634, 1635, 0, 1636, 1637, 1638, 1639, 1640, - 1641, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 1476, 0, 0, -787, 0, + 1477, 129, 130, 0, 131, 132, 133, 1478, 135, 136, + 137, 0, 1479, 1480, 1481, 1482, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 1483, + 1484, 155, 0, 156, 157, 158, 159, 0, 0, 1485, + 0, 1486, 163, 164, 165, 166, 167, 1487, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 1488, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 1489, 190, 191, 1490, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 1059, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 0, 221, 222, 223, 224, 225, 0, 0, 227, 0, + 228, 229, 1491, 231, 0, 232, 0, 233, 1492, 0, + 1493, 236, 237, -787, 1494, 240, 0, 241, 0, 0, + 0, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 1495, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 1496, 0, 268, 269, + 270, 271, 272, 1497, 1498, 0, 1499, 0, 276, 1500, + 1501, 279, 1502, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 1503, 289, 1504, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 1505, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 1506, 1507, 1508, 323, 324, + 325, 0, 0, 327, 328, 1509, 330, 0, 0, 332, + 1510, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 0, 1511, 346, 1512, + 0, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 0, 1513, + 364, 365, 0, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 1514, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 1515, + 400, 401, 402, 1516, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 1517, 417, + 418, 419, 420, 421, 422, 1518, 424, 425, 0, 1519, + 427, 428, 1520, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 1521, 444, 0, + 0, 0, 446, 447, 0, 448, 1522, 450, 451, 452, + 453, 454, 0, 455, 1523, 1524, 0, 0, 458, 459, + 0, 461, 0, 0, 463, 464, 1525, 466, 467, 468, + 469, 470, 1526, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 0, 1527, + 0, 485, 1528, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 523, 0, 549, 0, 0, 0, 0, 0, 0, + 0, 0, 512, 513, 514, 515, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 2971, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1631, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1632, 0, 0, -2041, -2041, -2041, - 0, 1636, 1637, 1638, 1639, 1640, 1641, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 837, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 838, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 839, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 840, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 841, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 950, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 839, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 841, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1632, 0, 0, 1633, 1634, 1635, 0, 1636, 1637, - 1638, 1639, 1640, 1641, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 1298, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 555, 0, 2079, 0, 0, - 0, 1632, 0, 0, 1633, 1634, 1635, 0, 1636, 1637, - 1638, 1639, 1640, 1641, 117, 118, 119, 120, 121, 122, - 123, 124, 556, 125, 126, 127, 557, 558, 559, 560, - 561, 562, 563, 564, 565, 129, 130, 566, 131, 132, - 133, 567, 135, 136, 137, 568, 569, 570, 571, 572, - 573, 143, 144, 145, 146, 147, 148, 574, 575, 149, - 150, 151, 152, 576, 577, 155, 578, 156, 157, 158, - 159, 579, 580, 581, 582, 583, 163, 164, 165, 166, - 167, 584, 169, 170, 171, 585, 172, 173, 174, 175, - 176, 177, 586, 587, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 589, 190, 191, 590, 193, 591, - 194, 592, 195, 196, 197, 198, 199, 200, 593, 594, - 201, 202, 203, 204, 595, 596, 205, 206, 207, 208, - 209, 597, 210, 211, 212, 598, 213, 214, 215, 599, - 216, 217, 218, 219, 600, 221, 222, 223, 224, 225, - 601, 602, 227, 603, 228, 229, 604, 231, 605, 232, - 606, 233, 607, 608, 609, 236, 237, 610, 611, 240, - 612, 241, 613, 614, 615, 244, 245, 616, 246, 247, - 248, 249, 250, 251, 252, 617, 254, 255, 256, 257, - 618, 258, 259, 260, 261, 262, 263, 264, 619, 265, - 620, 621, 268, 269, 270, 271, 272, 622, 623, 624, - 625, 626, 276, 627, 628, 279, 629, 281, 282, 283, - 284, 285, 286, 630, 631, 287, 632, 289, 633, 634, - 291, 292, 293, 294, 295, 296, 297, 298, 635, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 636, - 637, 638, 323, 324, 325, 639, 640, 327, 328, 641, - 330, 642, 643, 332, 644, 334, 335, 336, 645, 337, - 338, 646, 647, 339, 340, 341, 648, 649, 342, 343, - 650, 651, 346, 652, 653, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 654, 655, 656, 657, - 360, 361, 658, 659, 364, 365, 660, 367, 368, 369, - 661, 370, 371, 372, 373, 374, 375, 662, 376, 377, - 378, 663, 380, 381, 382, 383, 664, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 665, 397, 398, 666, 400, 401, 402, 667, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 668, 669, 417, 418, 419, 420, 421, 422, 670, - 424, 425, 671, 672, 427, 428, 673, 430, 674, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 675, 444, 676, 677, 678, 446, 447, 679, 448, - 680, 450, 451, 452, 453, 454, 681, 455, 682, 683, - 684, 685, 458, 459, 686, 461, 687, 688, 463, 464, - 689, 466, 467, 468, 469, 470, 690, 691, 471, 472, - 473, 692, 474, 475, 476, 477, 693, 478, 479, 480, - 481, 482, 694, 695, 696, 485, 697, 487, 488, 489, - 490, 491, 492, 493, 698, 699, 494, 700, 701, 495, - 496, 497, 498, 499, 500, 702, 703, 704, 705, 706, - 707, 708, 709, 710, 711, 712, 512, 513, 514, 515, - 555, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 556, 125, 126, - 127, 557, 558, 559, 560, 561, 562, 563, 564, 565, - 129, 130, 566, 131, 132, 133, 567, 135, 136, 137, - 568, 569, 570, 571, 572, 573, 143, 144, 145, 146, - 147, 148, 574, 575, 149, 150, 151, 152, 576, 577, - 155, 578, 156, 157, 158, 159, 579, 580, 581, 582, - 583, 163, 164, 165, 166, 167, 584, 169, 170, 171, - 585, 172, 173, 174, 175, 176, 177, 586, 587, 179, - 180, 181, 182, 183, 184, 588, 186, 187, 188, 589, - 190, 191, 590, 193, 591, 194, 592, 195, 196, 197, - 198, 199, 200, 593, 594, 201, 202, 203, 204, 595, - 596, 205, 206, 207, 208, 209, 597, 210, 211, 212, - 598, 213, 214, 215, 599, 216, 217, 218, 219, 600, - 221, 222, 223, 224, 225, 601, 602, 227, 603, 228, - 229, 604, 231, 605, 232, 606, 233, 607, 608, 609, - 236, 237, 610, 611, 240, 612, 241, 613, 614, 615, - 244, 245, 616, 246, 247, 248, 249, 250, 251, 252, - 617, 254, 255, 256, 257, 618, 258, 259, 260, 261, - 262, 263, 264, 619, 265, 620, 621, 268, 269, 270, - 271, 272, 622, 623, 624, 625, 626, 276, 627, 628, - 279, 629, 281, 282, 283, 284, 285, 286, 630, 631, - 287, 632, 289, 633, 634, 291, 292, 293, 294, 295, - 296, 297, 298, 635, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 636, 637, 638, 323, 324, 325, - 639, 640, 327, 328, 641, 330, 642, 643, 332, 644, - 334, 335, 336, 645, 337, 338, 646, 647, 339, 340, - 341, 648, 649, 342, 343, 650, 651, 346, 652, 653, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 654, 655, 656, 657, 360, 361, 658, 659, 364, - 365, 660, 367, 368, 369, 661, 370, 371, 372, 373, - 374, 375, 662, 376, 377, 378, 663, 380, 381, 382, - 383, 664, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 665, 397, 398, 666, 400, - 401, 402, 667, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 668, 669, 417, 418, - 419, 420, 421, 422, 670, 424, 425, 671, 672, 427, - 428, 673, 430, 674, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 675, 444, 676, 677, - 678, 446, 447, 679, 448, 680, 450, 451, 452, 453, - 454, 681, 455, 682, 683, 684, 685, 458, 459, 686, - 461, 687, 688, 463, 464, 689, 466, 467, 468, 469, - 470, 690, 691, 471, 472, 473, 692, 474, 475, 476, - 477, 693, 478, 479, 480, 481, 482, 694, 695, 696, - 485, 697, 487, 488, 489, 490, 491, 492, 493, 698, - 699, 494, 700, 701, 495, 496, 497, 498, 499, 500, - 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, - 712, 512, 513, 514, 515, 555, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 1319, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 556, 125, 126, 127, 557, 558, 559, 560, - 561, 562, 563, 564, 565, 129, 130, 566, 131, 132, - 133, 567, 135, 136, 137, 568, 569, 570, 571, 572, - 573, 143, 144, 145, 146, 147, 148, 574, 575, 149, - 150, 151, 152, 576, 577, 155, 578, 156, 157, 158, - 159, 579, 580, 581, 582, 583, 163, 164, 165, 166, - 167, 584, 169, 170, 171, 585, 172, 173, 174, 175, - 176, 177, 586, 587, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 589, 190, 191, 590, 193, 591, - 194, 592, 195, 196, 197, 198, 199, 200, 593, 594, - 201, 202, 203, 204, 595, 596, 205, 206, 207, 208, - 209, 597, 210, 211, 212, 598, 213, 214, 215, 599, - 216, 217, 218, 219, 600, 221, 222, 223, 224, 225, - 601, 602, 227, 603, 228, 229, 604, 231, 605, 232, - 606, 233, 607, 608, 609, 236, 237, 610, 611, 240, - 612, 241, 613, 614, 615, 244, 245, 616, 246, 247, - 248, 249, 250, 940, 252, 617, 254, 255, 256, 257, - 618, 258, 259, 260, 261, 262, 263, 264, 619, 265, - 620, 621, 268, 269, 270, 271, 272, 622, 623, 624, - 625, 626, 276, 627, 628, 279, 629, 281, 282, 283, - 284, 285, 286, 630, 631, 287, 632, 289, 633, 634, - 291, 292, 293, 294, 295, 296, 297, 298, 635, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 636, - 637, 638, 323, 324, 325, 639, 640, 327, 328, 641, - 330, 642, 643, 332, 644, 334, 335, 336, 645, 337, - 338, 646, 647, 339, 340, 341, 648, 649, 342, 343, - 650, 651, 346, 652, 653, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 654, 655, 656, 657, - 360, 361, 658, 659, 364, 365, 660, 367, 368, 369, - 661, 370, 371, 372, 373, 374, 375, 662, 376, 377, - 378, 663, 380, 381, 382, 383, 664, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 665, 397, 398, 666, 400, 401, 402, 667, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 668, 669, 417, 418, 419, 420, 421, 422, 670, - 424, 425, 671, 672, 427, 428, 673, 430, 674, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 675, 444, 676, 677, 678, 446, 447, 679, 448, - 680, 450, 451, 452, 453, 454, 681, 455, 682, 683, - 684, 685, 458, 459, 686, 461, 687, 688, 463, 464, - 689, 466, 467, 468, 469, 470, 690, 691, 471, 472, - 473, 692, 474, 475, 476, 477, 693, 478, 479, 480, - 481, 482, 694, 695, 696, 485, 697, 487, 488, 489, - 490, 491, 492, 493, 698, 699, 494, 700, 701, 495, - 496, 497, 498, 499, 500, 702, 703, 704, 705, 706, - 707, 708, 709, 710, 711, 712, 512, 513, 514, 515, - 555, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 556, 125, 126, - 127, 557, 558, 559, 560, 561, 562, 563, 564, 565, - 129, 130, 566, 131, 132, 133, 567, 135, 136, 137, - 568, 569, 570, 571, 572, 573, 143, 144, 145, 146, - 147, 148, 574, 575, 149, 150, 151, 152, 576, 577, - 155, 578, 156, 157, 158, 159, 579, 580, 581, 582, - 583, 163, 164, 165, 166, 167, 584, 169, 170, 171, - 585, 172, 173, 174, 175, 176, 177, 586, 587, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 589, - 190, 191, 590, 193, 591, 194, 592, 195, 196, 197, - 198, 199, 200, 593, 594, 201, 202, 203, 204, 595, - 596, 205, 206, 207, 208, 209, 597, 210, 211, 212, - 598, 213, 214, 215, 599, 216, 217, 218, 219, 600, - 221, 222, 223, 224, 225, 601, 602, 227, 603, 228, - 229, 604, 231, 605, 232, 606, 233, 607, 608, 609, - 236, 237, 610, 611, 240, 612, 241, 613, 614, 615, - 244, 245, 616, 246, 247, 248, 249, 250, 251, 252, - 617, 254, 255, 256, 257, 618, 258, 259, 260, 261, - 262, 263, 264, 619, 265, 620, 621, 268, 269, 270, - 271, 272, 622, 623, 624, 625, 626, 276, 627, 628, - 279, 629, 281, 282, 283, 284, 285, 286, 630, 631, - 287, 632, 289, 633, 634, 291, 292, 293, 294, 295, - 296, 297, 298, 635, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 636, 637, 638, 323, 324, 325, - 639, 640, 327, 328, 641, 330, 642, 643, 332, 644, - 334, 335, 336, 645, 337, 338, 646, 647, 339, 340, - 341, 648, 649, 342, 343, 650, 651, 346, 652, 653, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 654, 655, 656, 657, 360, 361, 658, 659, 364, - 365, 660, 367, 368, 369, 661, 370, 371, 372, 373, - 374, 375, 662, 376, 377, 378, 663, 380, 381, 382, - 383, 664, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 665, 397, 398, 666, 400, - 401, 402, 667, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 668, 669, 417, 418, - 419, 420, 421, 422, 670, 424, 425, 671, 672, 427, - 428, 673, 430, 674, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 675, 444, 676, 677, - 678, 446, 447, 679, 448, 680, 450, 451, 452, 453, - 454, 681, 455, 682, 683, 684, 685, 458, 459, 686, - 461, 687, 688, 463, 464, 689, 466, 467, 468, 469, - 470, 690, 691, 471, 472, 473, 692, 474, 475, 476, - 477, 693, 478, 479, 480, 481, 482, 694, 695, 696, - 485, 697, 487, 488, 489, 490, 491, 492, 493, 698, - 699, 494, 700, 701, 495, 496, 497, 498, 499, 500, - 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, - 712, 512, 513, 514, 515, 555, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 1670, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 0, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 2227, 122, - 123, 124, 556, 125, 126, 127, 557, 558, 559, 560, - 561, 562, 563, 564, 565, 129, 130, 566, 131, 132, - 133, 567, 135, 136, 137, 568, 569, 570, 571, 572, - 573, 143, 144, 145, 146, 147, 148, 574, 575, 149, - 150, 151, 152, 576, 577, 155, 578, 156, 157, 158, - 159, 579, 580, 581, 582, 583, 163, 164, 165, 166, - 167, 584, 169, 170, 171, 585, 172, 173, 174, 175, - 176, 177, 586, 587, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 589, 190, 191, 590, 193, 591, - 194, 592, 195, 196, 197, 198, 199, 200, 593, 594, - 201, 202, 203, 204, 595, 596, 205, 206, 207, 2228, - 209, 597, 210, 211, 212, 598, 213, 214, 215, 599, - 216, 217, 218, 219, 600, 221, 222, 223, 224, 225, - 601, 602, 227, 603, 228, 229, 604, 231, 605, 232, - 606, 233, 607, 608, 609, 236, 237, 610, 611, 240, - 612, 241, 613, 614, 615, 244, 245, 616, 246, 247, - 248, 249, 250, 251, 252, 617, 254, 255, 256, 257, - 618, 258, 259, 260, 261, 262, 263, 264, 619, 265, - 620, 621, 268, 269, 270, 271, 272, 622, 623, 624, - 625, 626, 276, 627, 628, 279, 629, 281, 282, 283, - 284, 285, 286, 630, 631, 287, 632, 289, 633, 634, - 291, 292, 293, 294, 295, 296, 297, 298, 635, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 636, - 637, 638, 323, 324, 325, 639, 640, 327, 328, 641, - 330, 642, 643, 332, 644, 334, 335, 336, 645, 337, - 338, 646, 647, 339, 340, 341, 648, 649, 342, 343, - 650, 651, 346, 652, 653, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 654, 655, 656, 657, - 360, 361, 658, 659, 364, 365, 660, 367, 368, 369, - 661, 370, 371, 372, 373, 374, 375, 662, 376, 377, - 378, 663, 380, 381, 382, 383, 664, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 665, 397, 398, 666, 400, 401, 402, 667, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 668, 669, 417, 418, 419, 420, 421, 2229, 670, - 424, 425, 671, 672, 427, 428, 673, 430, 674, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 675, 444, 676, 677, 678, 446, 447, 679, 448, - 680, 450, 451, 452, 453, 454, 681, 455, 682, 683, - 684, 685, 458, 459, 686, 461, 687, 688, 463, 464, - 689, 466, 467, 468, 469, 470, 690, 691, 471, 472, - 473, 692, 474, 475, 476, 477, 693, 478, 479, 480, - 481, 482, 694, 695, 696, 485, 697, 487, 488, 489, - 490, 491, 492, 493, 698, 699, 494, 700, 701, 495, - 496, 497, 498, 499, 500, 702, 703, 704, 705, 706, - 707, 708, 709, 710, 711, 712, 512, 513, 514, 515, - 964, 0, 815, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 560, 0, 0, 0, 0, 565, - 129, 130, 0, 131, 132, 133, 567, 135, 136, 137, - 568, 569, 570, 571, 572, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 576, 577, - 155, 0, 156, 157, 158, 159, 579, 0, 581, 0, - 583, 163, 164, 165, 166, 167, 584, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 587, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 589, - 190, 191, 590, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 600, - 221, 222, 223, 224, 225, 601, 1340, 227, 0, 228, - 229, 604, 231, 0, 232, 0, 233, 607, 0, 609, - 236, 237, 610, 611, 240, 0, 241, 0, 614, 615, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 617, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 620, 621, 268, 269, 270, - 271, 272, 622, 623, 0, 625, 0, 276, 627, 628, - 279, 629, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 632, 289, 633, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 635, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 636, 637, 638, 323, 324, 325, - 639, 0, 327, 328, 641, 330, 0, 643, 332, 644, - 334, 335, 336, 0, 337, 338, 1341, 0, 339, 340, - 341, 0, 0, 342, 343, 650, 651, 346, 652, 653, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 658, 659, 364, - 365, 660, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 663, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 666, 400, - 401, 402, 667, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 669, 417, 418, - 419, 420, 421, 422, 670, 424, 425, 0, 672, 427, - 428, 673, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 675, 444, 676, 0, - 0, 446, 447, 0, 448, 680, 450, 451, 452, 453, - 454, 0, 455, 682, 683, 0, 0, 458, 459, 686, - 461, 687, 1342, 463, 464, 689, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 694, 695, 0, - 485, 697, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, - 712, 512, 513, 514, 515, 964, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 1846, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 3, 4, 0, 560, - 0, 0, 0, 0, 565, 129, 130, 0, 131, 132, - 133, 567, 135, 136, 137, 568, 569, 570, 571, 572, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 576, 577, 155, 0, 156, 157, 158, - 159, 579, 0, 581, 0, 583, 163, 164, 165, 166, - 167, 584, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 587, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 589, 190, 191, 590, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 600, 221, 222, 223, 224, 225, - 601, 0, 227, 0, 228, 229, 604, 231, 0, 232, - 0, 233, 607, 0, 609, 236, 237, 610, 611, 240, - 0, 241, 0, 614, 615, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 617, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 620, 621, 268, 269, 270, 271, 272, 622, 623, 0, - 625, 0, 276, 627, 628, 279, 629, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 632, 289, 633, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 635, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 636, - 637, 638, 323, 324, 325, 639, 0, 327, 328, 641, - 330, 0, 643, 332, 644, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 650, 651, 346, 652, 653, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 658, 659, 364, 365, 660, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 663, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 666, 400, 401, 402, 667, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 669, 417, 418, 419, 420, 421, 422, 670, - 424, 425, 0, 672, 427, 428, 673, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 675, 444, 676, 0, 0, 446, 447, 0, 448, - 680, 450, 451, 452, 453, 454, 0, 455, 682, 683, - 0, 0, 458, 459, 686, 461, 687, 0, 463, 464, - 689, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 694, 695, 0, 485, 697, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 702, 703, 704, 705, 706, - 707, 708, 709, 710, 711, 712, 512, 513, 514, 515, - 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 128, - 129, 130, 0, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 785, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 786, 0, 787, 0, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 788, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 234, 0, 235, - 236, 237, 238, 239, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 288, 289, 290, 0, 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, 0, 327, 328, 329, 330, 0, 790, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 345, 346, 347, 792, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 793, 363, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 426, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 795, 0, - 0, 446, 447, 0, 448, 449, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 796, - 461, 797, 0, 463, 464, 798, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 244, 245, 0, 246, + 247, 248, 249, 250, 2215, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 128, 129, 130, 0, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 161, 0, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 234, 0, 235, 236, 237, 238, 239, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 288, 289, 290, 0, - 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, 0, 327, 328, 329, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 426, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 0, 0, 446, 447, 0, 448, - 449, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 486, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 1735, 156, 157, 158, 159, 160, 0, 0, 1736, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 1737, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 1738, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 1739, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 1740, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 1741, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 0, 131, 132, 133, 0, 135, 136, + 137, 138, 139, 0, 141, 142, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 153, + 154, 155, 0, 156, 157, 158, 159, 160, 0, 0, + 0, 162, 163, 164, 165, 166, 167, 0, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 0, 227, 0, + 228, 229, 230, 231, 0, 232, 0, 233, 0, 0, + 0, 236, 237, 524, 0, 240, 0, 241, 0, 242, + 243, 244, 245, 0, 246, 247, 248, 249, 250, 2230, + 252, 0, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 0, 275, 0, 276, 0, + 0, 279, 0, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 0, 289, 0, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 525, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 322, 323, 324, + 325, 326, 0, 327, 328, 0, 330, 0, 331, 332, + 333, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 344, 0, 346, 0, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 362, 0, + 364, 365, 366, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 0, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 0, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 0, 0, + 427, 428, 429, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 526, 444, 445, + 0, 0, 446, 447, 0, 448, 0, 450, 451, 452, + 453, 454, 0, 455, 456, 457, 0, 0, 458, 459, + 460, 461, 462, 0, 463, 464, 465, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 0, 485, 0, 487, 488, 489, 490, 491, 492, 493, + 0, 0, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 1475, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 1735, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 1737, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 1738, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 2309, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 1740, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 1741, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 3, 4, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 1476, 0, 0, 0, 0, 1477, 129, 130, 0, 131, + 132, 133, 1478, 135, 136, 137, 0, 1479, 1480, 1481, + 1482, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 1483, 1484, 155, 0, 156, 157, + 158, 159, 0, 0, 1485, 0, 1486, 163, 164, 165, + 166, 167, 1487, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 1488, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 1489, 190, 191, 1490, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 1059, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 0, 221, 222, 223, 224, + 225, 0, 0, 227, 0, 228, 229, 1491, 231, 0, + 232, 0, 233, 1492, 0, 1493, 236, 237, 0, 1494, + 240, 0, 241, 0, 0, 0, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 1495, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 1496, 0, 268, 269, 270, 271, 272, 1497, 1498, + 0, 1499, 0, 276, 1500, 1501, 279, 1502, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 1503, 289, 1504, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 1505, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 1506, 1507, 1508, 323, 324, 325, 0, 0, 327, 328, + 1509, 330, 0, 0, 332, 1510, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 0, 1511, 346, 1512, 0, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 0, 1513, 364, 365, 0, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 1514, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 1515, 400, 401, 402, 1516, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 1517, 417, 418, 419, 420, 421, 422, + 1518, 424, 425, 0, 1519, 427, 428, 1520, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 1521, 444, 0, 0, 0, 446, 447, 0, + 448, 1522, 450, 451, 452, 453, 454, 0, 455, 1523, + 1524, 0, 0, 458, 459, 0, 461, 0, 0, 463, + 464, 1525, 466, 467, 468, 469, 470, 1526, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 0, 1527, 0, 485, 1528, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 1475, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 512, 513, 514, + 515, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 1476, 0, 0, 0, 0, 1477, 129, 130, 0, 131, + 132, 133, 1478, 135, 136, 137, 0, 1479, 1480, 1481, + 1482, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 1483, 1484, 155, 0, 156, 157, + 158, 159, 0, 0, 1485, 0, 1486, 163, 164, 165, + 166, 167, 1487, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 1488, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 1489, 190, 191, 1490, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 1059, + 208, 209, 0, 210, 211, 212, 0, 1828, 214, 215, + 0, 216, 217, 218, 219, 0, 221, 222, 223, 224, + 225, 0, 0, 227, 0, 228, 229, 1491, 231, 0, + 232, 0, 233, 1492, 0, 1493, 236, 237, 0, 1494, + 240, 0, 241, 0, 0, 0, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 1495, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 1496, 0, 268, 269, 270, 271, 272, 1497, 1498, + 0, 1499, 0, 276, 1500, 1501, 279, 1502, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 1503, 289, 1504, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 1505, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 1506, 1507, 1508, 323, 324, 325, 0, 0, 327, 328, + 1509, 330, 0, 0, 332, 1510, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 0, 1511, 346, 1512, 0, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 0, 1513, 364, 365, 0, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 1514, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 1515, 400, 401, 402, 1516, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 1517, 417, 418, 419, 420, 421, 422, + 1518, 424, 425, 0, 1519, 427, 428, 1520, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 1521, 444, 0, 0, 0, 446, 447, 0, + 448, 1522, 450, 451, 452, 453, 454, 0, 455, 1523, + 1524, 0, 0, 458, 459, 0, 461, 0, 0, 463, + 464, 1525, 466, 467, 468, 469, 470, 1526, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 0, 1527, 0, 485, 1528, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 3141, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 512, 513, 514, + 515, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 2893, 0, 0, 0, 0, 2894, 129, 130, 0, 131, + 132, 133, 2895, 135, 136, 137, 0, 1479, 2896, 1481, + 1482, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 1483, 1484, 155, 0, 156, 157, + 158, 159, 0, 0, 2897, 0, 2898, 163, 164, 165, + 166, 167, 2899, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 2900, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 1489, 190, 191, 1490, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 1059, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 0, 221, 222, 223, 224, + 225, 0, 0, 227, 0, 228, 229, 1491, 231, 0, + 232, 0, 233, 2901, 0, 2902, 236, 237, 2903, 2904, + 240, 0, 241, 0, 0, 0, 244, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 2905, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 2906, 0, 268, 269, 270, 271, 272, 1497, 1498, + 0, 1499, 0, 276, 2907, 2908, 279, 2909, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 2910, 289, 2911, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 3142, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 1506, 2913, 1508, 323, 324, 325, 0, 0, 327, 328, + 2915, 330, 0, 0, 332, 1510, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 0, 2917, 346, 2918, 0, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 0, 2919, 364, 365, 0, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 377, 378, 1514, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 2920, 400, 401, 402, 0, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 2921, 417, 418, 419, 420, 421, 422, + 0, 424, 425, 0, 2923, 427, 428, 1520, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 3143, 444, 0, 0, 0, 446, 447, 0, + 448, 2925, 450, 451, 452, 453, 454, 0, 455, 1523, + 1524, 0, 0, 458, 459, 0, 461, 0, 0, 463, + 464, 2926, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 0, 1527, 0, 485, 2928, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 523, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 512, 513, 514, + 515, 0, 0, 0, 0, 117, 118, 119, 120, 121, + 122, 123, 124, 0, 125, 126, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 0, 131, + 132, 133, 0, 135, 136, 137, 138, 139, 0, 141, + 142, 0, 143, 144, 145, 146, 147, 148, 0, 0, + 149, 150, 151, 152, 153, 154, 155, 0, 156, 157, + 158, 159, 160, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 0, 169, 170, 171, 0, 172, 173, 174, + 175, 176, 177, 0, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 0, 194, 0, 195, 196, 197, 198, 199, 200, 0, + 0, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 209, 0, 210, 211, 212, 0, 213, 214, 215, + 0, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 0, 227, 0, 228, 229, 230, 231, 0, + 232, 0, 233, 0, 0, 0, 236, 237, 524, 0, + 240, 0, 241, 0, 242, 243, 0, 245, 0, 246, + 247, 248, 249, 250, 251, 252, 0, 254, 255, 256, + 257, 0, 258, 259, 260, 261, 262, 263, 264, 0, + 265, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 0, 275, 0, 276, 0, 0, 279, 0, 281, 282, + 283, 284, 285, 286, 0, 0, 287, 0, 289, 0, + 0, 291, 292, 293, 294, 295, 296, 297, 298, 525, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 322, 323, 324, 325, 326, 0, 327, 328, + 0, 330, 0, 331, 332, 333, 334, 335, 336, 0, + 337, 338, 0, 0, 339, 340, 341, 0, 0, 342, + 343, 344, 0, 346, 0, 348, 349, 350, 351, 352, + 353, 354, 0, 356, 357, 358, 359, 0, 0, 0, + 0, 360, 361, 362, 0, 364, 365, 366, 367, 368, + 369, 0, 370, 371, 372, 373, 374, 375, 0, 376, + 0, 378, 379, 380, 381, 382, 383, 0, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 0, 397, 398, 0, 400, 401, 402, 403, 0, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 0, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 0, 0, 427, 428, 429, 430, 0, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 526, 444, 445, 0, 0, 446, 447, 0, + 448, 0, 450, 451, 452, 453, 454, 0, 455, 456, + 457, 0, 0, 458, 459, 460, 461, 462, 0, 463, + 464, 465, 466, 467, 468, 469, 470, 0, 0, 471, + 472, 473, 0, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 0, 485, 0, 487, 488, + 489, 490, 491, 492, 493, 0, 0, 494, 0, 0, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 1765, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 550, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 551, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 791, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, + 117, 118, 119, 120, 121, 122, 123, 124, 0, 125, + 126, 127, 0, 0, 0, 1476, 0, 0, 0, 0, + 1477, 129, 130, 0, 131, 132, 133, 1478, 135, 136, + 137, 0, 1479, 1480, 1481, 1482, 0, 143, 144, 145, + 146, 147, 148, 0, 0, 149, 150, 151, 152, 1483, + 1484, 155, 0, 156, 157, 158, 159, 0, 0, 1485, + 0, 1486, 163, 164, 165, 166, 167, 1487, 169, 170, + 171, 0, 172, 173, 174, 175, 176, 177, 0, 1488, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 1489, 190, 191, 1490, 193, 0, 194, 0, 195, 196, + 197, 198, 199, 200, 0, 0, 201, 202, 203, 204, + 0, 0, 205, 206, 1059, 208, 209, 0, 210, 211, + 212, 0, 213, 214, 215, 0, 216, 217, 218, 219, + 0, 221, 222, 223, 224, 225, 0, 0, 227, 0, + 228, 229, 1491, 231, 0, 232, 0, 233, 1492, 0, + 1493, 236, 237, 0, 1494, 240, 0, 241, 0, 0, + 0, 244, 245, 0, 246, 247, 248, 249, 250, 251, + 252, 1495, 254, 255, 256, 257, 0, 258, 259, 260, + 261, 262, 263, 264, 0, 265, 1496, 0, 268, 269, + 270, 271, 272, 1497, 1498, 0, 1499, 0, 276, 1500, + 1501, 279, 1502, 281, 282, 283, 284, 285, 286, 0, + 0, 287, 1503, 289, 1504, 0, 291, 292, 293, 294, + 295, 296, 297, 298, 0, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 1506, 1507, 1508, 323, 324, + 325, 0, 0, 327, 328, 1509, 330, 0, 0, 332, + 1510, 334, 335, 336, 0, 337, 338, 0, 0, 339, + 340, 341, 0, 0, 342, 343, 0, 1511, 346, 1512, + 0, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 0, 0, 0, 0, 360, 361, 0, 1513, + 364, 365, 0, 367, 368, 369, 0, 370, 371, 372, + 373, 374, 375, 0, 376, 377, 378, 1514, 380, 381, + 382, 383, 0, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 398, 1515, + 400, 401, 402, 0, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 0, 1517, 417, + 418, 419, 420, 421, 422, 0, 424, 425, 0, 1519, + 427, 428, 1520, 430, 0, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 0, 444, 0, + 0, 0, 446, 447, 0, 448, 1522, 450, 451, 452, + 453, 454, 0, 455, 1523, 1524, 0, 0, 458, 459, + 0, 461, 0, 0, 463, 464, 1525, 466, 467, 468, + 469, 470, 0, 0, 471, 472, 473, 0, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 0, 1527, + 0, 485, 1528, 487, 488, 489, 490, 491, 492, 493, + 0, 1, 494, 0, 0, 495, 496, 497, 498, 499, + 500, 2, 0, 3, 4, 0, 0, 0, 0, 1, + 0, 0, 512, 513, 514, 515, 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, 746, + 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 11, 0, 746, 0, 0, + 0, 0, 0, 0, 0, 14, 15, 0, 13, 0, + 0, 0, 0, 0, 0, 0, 747, 0, 0, 0, + 0, 0, 18, 14, 15, 0, 0, 0, 0, 0, + 19, 0, 0, 0, 747, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 22, 0, 19, 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, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 896, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 791, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 938, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 1939, 0, 0, 0, - 0, 1940, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 1947, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 1948, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 1949, 448, 0, 450, 1950, 452, 1951, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 1952, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 815, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 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, 117, 118, 119, 120, 121, 122, - 123, 124, 822, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 823, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 824, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 825, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 826, 457, - 0, 0, 827, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 859, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, + 25, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 891, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 894, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, + 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 898, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 926, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 954, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 957, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 1000, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 1023, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 822, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 826, 457, - 0, 0, 827, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 1298, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 1300, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 1303, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 549, 0, 0, + 0, 0, 0, 27, 28, 29, 0, 0, 0, 0, + 0, 30, 0, 0, 31, 0, 0, 0, 0, 0, + 0, 27, 28, 29, 0, 0, 0, 0, 0, 30, + 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 33, 0, 0, 0, 0, 0, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 34, 0, + 33, 0, 0, 0, 0, 35, 0, 0, 0, 36, + 0, 0, 0, 0, 0, 0, 34, 0, 0, 37, + 0, 0, 0, 35, 0, 0, 0, 36, 0, 0, + 0, 38, 0, 0, 0, 39, 0, 37, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 38, + 0, 0, 0, 39, 0, 40, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 41, 0, + 0, 0, 0, 40, 43, 0, 0, 0, 0, 44, + 0, 0, 0, 748, 0, 0, 41, 0, 0, 0, + 0, 0, 43, 0, 0, 45, 0, 44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 1305, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 549, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 2223, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 1472, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 1473, - 0, 0, -785, 0, 1474, 129, 130, 0, 131, 132, - 133, 1475, 135, 136, 137, 0, 1476, 1477, 1478, 1479, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 1480, 1481, 155, 0, 156, 157, 158, - 159, 0, 0, 1482, 0, 1483, 163, 164, 165, 166, - 167, 1484, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 1485, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 1486, 190, 191, 1487, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 1059, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 0, 221, 222, 223, 224, 225, - 0, 0, 227, 0, 228, 229, 1488, 231, 0, 232, - 0, 233, 1489, 0, 1490, 236, 237, -785, 1491, 240, - 0, 241, 0, 0, 0, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 1492, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 1493, 0, 268, 269, 270, 271, 272, 1494, 1495, 0, - 1496, 0, 276, 1497, 1498, 279, 1499, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 1500, 289, 1501, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 1502, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 1503, - 1504, 1505, 323, 324, 325, 0, 0, 327, 328, 1506, - 330, 0, 0, 332, 1507, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 0, 1508, 346, 1509, 0, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 0, 1510, 364, 365, 0, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 1511, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 1512, 400, 401, 402, 1513, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 1514, 417, 418, 419, 420, 421, 422, 1515, - 424, 425, 0, 1516, 427, 428, 1517, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 1518, 444, 0, 0, 0, 446, 447, 0, 448, - 1519, 450, 451, 452, 453, 454, 0, 455, 1520, 1521, - 0, 0, 458, 459, 0, 461, 0, 0, 463, 464, - 1522, 466, 467, 468, 469, 470, 1523, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 0, 1524, 0, 485, 1525, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 523, 0, 549, 0, 0, - 0, 0, 0, 0, 0, 0, 512, 513, 514, 515, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 2964, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 837, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 838, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 839, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 840, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 841, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 950, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 839, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 841, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 1307, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 1318, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 1667, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 0, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 1843, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 244, 245, 0, 246, 247, 248, 249, 250, 2210, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 523, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 0, 131, 132, - 133, 0, 135, 136, 137, 138, 139, 0, 141, 142, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 153, 154, 155, 0, 156, 157, 158, - 159, 160, 0, 0, 0, 162, 163, 164, 165, 166, - 167, 0, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 0, 227, 0, 228, 229, 230, 231, 0, 232, - 0, 233, 0, 0, 0, 236, 237, 524, 0, 240, - 0, 241, 0, 242, 243, 244, 245, 0, 246, 247, - 248, 249, 250, 2225, 252, 0, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 0, - 275, 0, 276, 0, 0, 279, 0, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 0, 289, 0, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 525, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 0, 322, 323, 324, 325, 326, 0, 327, 328, 0, - 330, 0, 331, 332, 333, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 344, 0, 346, 0, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 362, 0, 364, 365, 366, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 379, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 0, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 0, 0, 427, 428, 429, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 526, 444, 445, 0, 0, 446, 447, 0, 448, - 0, 450, 451, 452, 453, 454, 0, 455, 456, 457, - 0, 0, 458, 459, 460, 461, 462, 0, 463, 464, - 465, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 0, 485, 0, 487, 488, 489, - 490, 491, 492, 493, 0, 0, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 1472, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 1473, 0, 0, 0, 0, 1474, - 129, 130, 0, 131, 132, 133, 1475, 135, 136, 137, - 0, 1476, 1477, 1478, 1479, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 1480, 1481, - 155, 0, 156, 157, 158, 159, 0, 0, 1482, 0, - 1483, 163, 164, 165, 166, 167, 1484, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 1485, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 1486, - 190, 191, 1487, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 1059, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 0, - 221, 222, 223, 224, 225, 0, 0, 227, 0, 228, - 229, 1488, 231, 0, 232, 0, 233, 1489, 0, 1490, - 236, 237, 0, 1491, 240, 0, 241, 0, 0, 0, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 1492, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 1493, 0, 268, 269, 270, - 271, 272, 1494, 1495, 0, 1496, 0, 276, 1497, 1498, - 279, 1499, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 1500, 289, 1501, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 1502, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 1503, 1504, 1505, 323, 324, 325, - 0, 0, 327, 328, 1506, 330, 0, 0, 332, 1507, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 0, 1508, 346, 1509, 0, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 0, 1510, 364, - 365, 0, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 1511, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 1512, 400, - 401, 402, 1513, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 1514, 417, 418, - 419, 420, 421, 422, 1515, 424, 425, 0, 1516, 427, - 428, 1517, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 1518, 444, 0, 0, - 0, 446, 447, 0, 448, 1519, 450, 451, 452, 453, - 454, 0, 455, 1520, 1521, 0, 0, 458, 459, 0, - 461, 0, 0, 463, 464, 1522, 466, 467, 468, 469, - 470, 1523, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 0, 1524, 0, - 485, 1525, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 1472, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 512, 513, 514, 515, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 1473, 0, 0, 0, 0, 1474, - 129, 130, 0, 131, 132, 133, 1475, 135, 136, 137, - 0, 1476, 1477, 1478, 1479, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 1480, 1481, - 155, 0, 156, 157, 158, 159, 0, 0, 1482, 0, - 1483, 163, 164, 165, 166, 167, 1484, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 1485, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 1486, - 190, 191, 1487, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 1059, 208, 209, 0, 210, 211, 212, - 0, 1825, 214, 215, 0, 216, 217, 218, 219, 0, - 221, 222, 223, 224, 225, 0, 0, 227, 0, 228, - 229, 1488, 231, 0, 232, 0, 233, 1489, 0, 1490, - 236, 237, 0, 1491, 240, 0, 241, 0, 0, 0, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 1492, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 1493, 0, 268, 269, 270, - 271, 272, 1494, 1495, 0, 1496, 0, 276, 1497, 1498, - 279, 1499, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 1500, 289, 1501, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 1502, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 1503, 1504, 1505, 323, 324, 325, - 0, 0, 327, 328, 1506, 330, 0, 0, 332, 1507, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 0, 1508, 346, 1509, 0, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 0, 1510, 364, - 365, 0, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 1511, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 1512, 400, - 401, 402, 1513, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 1514, 417, 418, - 419, 420, 421, 422, 1515, 424, 425, 0, 1516, 427, - 428, 1517, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 1518, 444, 0, 0, - 0, 446, 447, 0, 448, 1519, 450, 451, 452, 453, - 454, 0, 455, 1520, 1521, 0, 0, 458, 459, 0, - 461, 0, 0, 463, 464, 1522, 466, 467, 468, 469, - 470, 1523, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 0, 1524, 0, - 485, 1525, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 3135, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 512, 513, 514, 515, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 2886, 0, 0, 0, 0, 2887, - 129, 130, 0, 131, 132, 133, 2888, 135, 136, 137, - 0, 1476, 2889, 1478, 1479, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 1480, 1481, - 155, 0, 156, 157, 158, 159, 0, 0, 2890, 0, - 2891, 163, 164, 165, 166, 167, 2892, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 2893, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 1486, - 190, 191, 1487, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 1059, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 0, - 221, 222, 223, 224, 225, 0, 0, 227, 0, 228, - 229, 1488, 231, 0, 232, 0, 233, 2894, 0, 2895, - 236, 237, 2896, 2897, 240, 0, 241, 0, 0, 0, - 244, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 2898, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 2899, 0, 268, 269, 270, - 271, 272, 1494, 1495, 0, 1496, 0, 276, 2900, 2901, - 279, 2902, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 2903, 289, 2904, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 3136, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 1503, 2906, 1505, 323, 324, 325, - 0, 0, 327, 328, 2908, 330, 0, 0, 332, 1507, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 0, 2910, 346, 2911, 0, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 0, 2912, 364, - 365, 0, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 377, 378, 1511, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 2913, 400, - 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 2914, 417, 418, - 419, 420, 421, 422, 0, 424, 425, 0, 2916, 427, - 428, 1517, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 3137, 444, 0, 0, - 0, 446, 447, 0, 448, 2918, 450, 451, 452, 453, - 454, 0, 455, 1520, 1521, 0, 0, 458, 459, 0, - 461, 0, 0, 463, 464, 2919, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 0, 1524, 0, - 485, 2921, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 523, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 512, 513, 514, 515, 0, 0, 0, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 0, 131, 132, 133, 0, 135, 136, 137, - 138, 139, 0, 141, 142, 0, 143, 144, 145, 146, - 147, 148, 0, 0, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 0, 0, 0, - 162, 163, 164, 165, 166, 167, 0, 169, 170, 171, - 0, 172, 173, 174, 175, 176, 177, 0, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 0, 194, 0, 195, 196, 197, - 198, 199, 200, 0, 0, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 209, 0, 210, 211, 212, - 0, 213, 214, 215, 0, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 0, 227, 0, 228, - 229, 230, 231, 0, 232, 0, 233, 0, 0, 0, - 236, 237, 524, 0, 240, 0, 241, 0, 242, 243, - 0, 245, 0, 246, 247, 248, 249, 250, 251, 252, - 0, 254, 255, 256, 257, 0, 258, 259, 260, 261, - 262, 263, 264, 0, 265, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 0, 275, 0, 276, 0, 0, - 279, 0, 281, 282, 283, 284, 285, 286, 0, 0, - 287, 0, 289, 0, 0, 291, 292, 293, 294, 295, - 296, 297, 298, 525, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 0, 322, 323, 324, 325, - 326, 0, 327, 328, 0, 330, 0, 331, 332, 333, - 334, 335, 336, 0, 337, 338, 0, 0, 339, 340, - 341, 0, 0, 342, 343, 344, 0, 346, 0, 348, - 349, 350, 351, 352, 353, 354, 0, 356, 357, 358, - 359, 0, 0, 0, 0, 360, 361, 362, 0, 364, - 365, 366, 367, 368, 369, 0, 370, 371, 372, 373, - 374, 375, 0, 376, 0, 378, 379, 380, 381, 382, - 383, 0, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 398, 0, 400, - 401, 402, 403, 0, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 0, 0, 427, - 428, 429, 430, 0, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 526, 444, 445, 0, - 0, 446, 447, 0, 448, 0, 450, 451, 452, 453, - 454, 0, 455, 456, 457, 0, 0, 458, 459, 460, - 461, 462, 0, 463, 464, 465, 466, 467, 468, 469, - 470, 0, 0, 471, 472, 473, 0, 474, 475, 476, - 477, 0, 478, 479, 480, 481, 482, 483, 484, 0, - 485, 0, 487, 488, 489, 490, 491, 492, 493, 0, - 0, 494, 0, 0, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 1762, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 118, 119, 120, 121, 122, - 123, 124, 0, 125, 126, 127, 0, 0, 0, 1473, - 0, 0, 0, 0, 1474, 129, 130, 0, 131, 132, - 133, 1475, 135, 136, 137, 0, 1476, 1477, 1478, 1479, - 0, 143, 144, 145, 146, 147, 148, 0, 0, 149, - 150, 151, 152, 1480, 1481, 155, 0, 156, 157, 158, - 159, 0, 0, 1482, 0, 1483, 163, 164, 165, 166, - 167, 1484, 169, 170, 171, 0, 172, 173, 174, 175, - 176, 177, 0, 1485, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 1486, 190, 191, 1487, 193, 0, - 194, 0, 195, 196, 197, 198, 199, 200, 0, 0, - 201, 202, 203, 204, 0, 0, 205, 206, 1059, 208, - 209, 0, 210, 211, 212, 0, 213, 214, 215, 0, - 216, 217, 218, 219, 0, 221, 222, 223, 224, 225, - 0, 0, 227, 0, 228, 229, 1488, 231, 0, 232, - 0, 233, 1489, 0, 1490, 236, 237, 0, 1491, 240, - 0, 241, 0, 0, 0, 244, 245, 0, 246, 247, - 248, 249, 250, 251, 252, 1492, 254, 255, 256, 257, - 0, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 1493, 0, 268, 269, 270, 271, 272, 1494, 1495, 0, - 1496, 0, 276, 1497, 1498, 279, 1499, 281, 282, 283, - 284, 285, 286, 0, 0, 287, 1500, 289, 1501, 0, - 291, 292, 293, 294, 295, 296, 297, 298, 0, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 1503, - 1504, 1505, 323, 324, 325, 0, 0, 327, 328, 1506, - 330, 0, 0, 332, 1507, 334, 335, 336, 0, 337, - 338, 0, 0, 339, 340, 341, 0, 0, 342, 343, - 0, 1508, 346, 1509, 0, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 0, 0, 0, 0, - 360, 361, 0, 1510, 364, 365, 0, 367, 368, 369, - 0, 370, 371, 372, 373, 374, 375, 0, 376, 377, - 378, 1511, 380, 381, 382, 383, 0, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 0, 397, 398, 1512, 400, 401, 402, 0, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 0, 1514, 417, 418, 419, 420, 421, 422, 0, - 424, 425, 0, 1516, 427, 428, 1517, 430, 0, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 0, 444, 0, 0, 0, 446, 447, 0, 448, - 1519, 450, 451, 452, 453, 454, 0, 455, 1520, 1521, - 0, 0, 458, 459, 0, 461, 0, 0, 463, 464, - 1522, 466, 467, 468, 469, 470, 0, 0, 471, 472, - 473, 0, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 0, 1524, 0, 485, 1525, 487, 488, 489, - 490, 491, 492, 493, 0, 1, 494, 0, 0, 495, - 496, 497, 498, 499, 500, 2, 0, 3, 4, 0, - 0, 0, 0, 1, 0, 0, 512, 513, 514, 515, - 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, 746, 0, 0, 0, 10, 0, 0, - 0, 0, 0, 0, 13, 0, 0, 0, 0, 11, - 0, 746, 0, 0, 0, 0, 0, 0, 0, 14, - 15, 0, 13, 0, 0, 0, 0, 0, 0, 0, - 747, 0, 0, 0, 0, 0, 18, 14, 15, 0, - 0, 0, 0, 0, 19, 0, 0, 0, 747, 0, - 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, - 22, 0, 19, 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, - 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, - 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 45, 0, 0, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 749, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 27, 28, 29, - 0, 0, 0, 0, 0, 30, 0, 0, 31, 0, - 0, 0, 0, 0, 0, 27, 28, 29, 0, 0, - 0, 0, 0, 30, 0, 0, 31, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, - 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, - 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, - 0, 0, 34, 0, 33, 0, 0, 0, 0, 35, - 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, - 34, 0, 0, 37, 0, 0, 0, 35, 0, 0, - 0, 36, 0, 0, 0, 38, 0, 0, 0, 39, - 0, 37, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 38, 0, 0, 0, 39, 0, 40, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 41, 0, 0, 0, 0, 40, 43, 0, - 0, 0, 0, 44, 0, 0, 0, 748, 0, 0, - 41, 0, 0, 0, 0, 0, 43, 0, 0, 45, - 0, 44, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, - 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 749, 0, 0, - 0, 46, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 47 + 0, 47 }; static const yytype_int16 yycheck[] = { - 7, 0, 0, 516, 7, 89, 90, 895, 0, 16, - 87, 0, 835, 741, 920, 883, 23, 0, 858, 809, - 23, 990, 0, 0, 1221, 1570, 904, 981, 47, 1416, - 23, 1220, 7, 0, 16, 1689, 0, 1195, 0, 0, - 1234, 1032, 20, 20, 925, 972, 749, 1208, 23, 1155, - 981, 2156, 981, 955, 1651, 91, 981, 1462, 17, 91, - 23, 1197, 20, 959, 1079, 2269, 2270, 2271, 1981, 39, - 1321, 1200, 2221, 1296, 38, 1161, 0, 972, 2166, 1604, - 1605, 2640, 89, 90, 35, 1793, 89, 90, 2155, 1225, - 2135, 0, 2137, 1274, 0, 0, 89, 90, 2331, 46, - 0, 895, 0, 897, 26, 899, 1982, 2602, 0, 2638, - 0, 972, 1122, 2602, 89, 90, 2661, 1127, 1087, 2101, - 0, 999, 748, 0, 2217, 0, 89, 90, 2654, 0, - 0, 2476, 0, 0, 749, 2288, 0, 0, 102, 979, - 110, 0, 805, 0, 0, 1817, 1655, 810, 2558, 742, - 5, 0, 2562, 0, 0, 5, 9, 11, 13, 14, - 1707, 15, 16, 80, 1814, 2973, 11, 1709, 5, 5, - 767, 16, 5, 3, 1924, 5, 13, 14, 5, 5, - 5, 1053, 1054, 5, 9, 63, 13, 14, 5, 55, - 5, 5, 982, 5, 9, 5, 1811, 5, 1070, 2299, - 5, 13, 14, 13, 14, 5, 1133, 45, 2295, 5, - 2959, 5, 172, 2306, 107, 5, 5, 5, 5, 5, - 2300, 13, 14, 119, 139, 45, 2428, 2976, 63, 147, - 74, 13, 14, 122, 37, 4, 3, 4, 5, 42, - 9, 82, 9, 161, 171, 1106, 1086, 9, 166, 3140, - 1241, 100, 93, 5, 100, 878, 190, 11, 2814, 1250, - 1138, 15, 16, 4, 2357, 2358, 82, 2360, 9, 972, - 177, 122, 1133, 11, 878, 147, 180, 93, 16, 11, - 290, 1033, 1209, 15, 16, 1212, 1213, 295, 53, 802, - 1957, 63, 46, 124, 177, 873, 244, 3, 101, 217, - 104, 244, 63, 1970, 289, 171, 11, 287, 46, 295, - 15, 16, 2795, 192, 2797, 2932, 90, 2521, 275, 237, - 983, 119, 379, 212, 168, 1431, 80, 107, 34, 35, - 3304, 171, 995, 240, 117, 13, 14, 850, 132, 312, - 13, 46, 80, 312, 107, 217, 19, 973, 1209, 1189, - 117, 1212, 1213, 106, 1515, 129, 1462, 240, 31, 1950, - 1951, 1952, 1185, 1186, 132, 159, 2411, 2860, 286, 172, - 183, 342, 45, 46, 30, 80, 180, 295, 120, 64, - 1057, 1133, 38, 30, 30, 1608, 108, 165, 2572, 74, - 40, 38, 38, 366, 454, 172, 1073, 406, 1304, 122, - 365, 192, 161, 11, 388, 208, 313, 163, 41, 2968, - 381, 176, 1280, 1894, 137, 3337, 2124, 120, 3167, 3472, - 2979, 224, 2571, 295, 33, 476, 2915, 370, 193, 4, - 75, 234, 108, 198, 9, 108, 2520, 272, 2522, 1548, - 289, 2970, 249, 289, 1925, 416, 509, 148, 1557, 500, - 59, 218, 194, 516, 514, 1336, 1208, 3431, 2546, 468, - 3513, 518, 3270, 370, 170, 268, 172, 274, 272, 191, - 377, 236, 80, 240, 230, 2568, 355, 2570, 237, 357, - 274, 279, 1343, 1344, 328, 279, 2468, 370, 166, 2673, - 284, 194, 272, 126, 451, 466, 279, 250, 199, 40, - 448, 428, 163, 278, 514, 448, 1521, 260, 3430, 358, - 518, 314, 358, 420, 3405, 422, 284, 3000, 321, 1742, - 2722, 3138, 357, 416, 337, 175, 444, 279, 3084, 514, - 514, 308, 518, 307, 514, 8, 509, 420, 11, 422, - 509, 448, 15, 16, 1296, 323, 19, 20, 21, 514, - 454, 386, 1149, 366, 514, 240, 2101, 472, 361, 3367, - 456, 352, 451, 2650, 1187, 448, 514, 2667, 213, 1974, - 534, 514, 444, 403, 404, 413, 503, 380, 1736, 1092, - 514, 588, 1422, 1187, 1162, 357, 2499, 428, 428, 516, - 2683, 2671, 1320, 413, 512, 512, 357, 1325, 516, 516, - 451, 445, 1853, 1331, 327, 3098, 588, 370, 1480, 1481, - 271, 514, 428, 1436, 2139, 392, 1797, 2367, 393, 3368, - 2165, 425, 2706, 454, 3117, 2172, 391, 476, 3154, 1452, - 476, 2173, 1829, 1505, 175, 1338, 265, 463, 503, 149, - 518, 435, 476, 132, 478, 3140, 449, 421, 514, 514, - 2159, 3140, 446, 507, 508, 509, 510, 2329, 2308, 514, - 513, 478, 1653, 1886, 514, 510, 515, 522, 517, 515, - 517, 517, 522, 478, 1868, 1898, 512, 514, 514, 3089, - 516, 514, 2831, 500, 3094, 2838, 2301, 514, 514, 514, - 200, 320, 514, 1565, 1566, 500, 117, 514, 3043, 514, - 514, 1562, 514, 289, 514, 1928, 514, 1547, 1548, 514, - 3269, 1337, 1935, 1574, 514, 1576, 800, 1557, 514, 1597, - 1598, 1599, 514, 1338, 514, 514, 514, 514, 514, 2962, - 749, 1571, 514, 3278, 1327, 476, 505, 506, 505, 506, - 396, 1602, 749, 505, 506, 2812, 518, 2951, 1971, 396, - 396, 3277, 1975, 507, 508, 509, 510, 2424, 464, 500, - 1600, 30, 108, 1515, 505, 506, 1429, 3381, 161, 190, - 748, 748, 510, 505, 506, 507, 508, 509, 510, 30, - 2003, 800, 789, 161, 2697, 274, 789, 356, 166, 161, - 3070, 749, 3072, 800, 166, 284, 415, 800, 1979, 430, - 505, 506, 507, 508, 509, 510, 883, 800, 71, 72, - 1487, 454, 848, 244, 789, 244, 848, 386, 291, 503, - 3379, 2412, 2413, 2414, 2415, 800, 789, 82, 835, 836, - 1507, 1937, 516, 416, 453, 3364, 2818, 800, 93, 1766, - 258, 259, 0, 26, 237, 1706, 1707, 1838, 479, 1776, - 478, 858, 1779, 274, 3468, 2731, 1608, 517, 2734, 237, - 2736, 2774, 784, 132, 2957, 237, 1543, 2865, 1974, 868, - 868, 514, 500, 1761, 2125, 2873, 868, 464, 551, 868, - 177, 132, 3230, 853, 3232, 868, 837, 838, 244, 840, - 868, 868, 1620, 286, 3423, 902, 903, 1410, 856, 906, - 907, 868, 518, 873, 868, 1766, 868, 868, 286, 2617, - 3405, 2619, 859, 3193, 286, 1776, 3405, 37, 1779, 82, - 3271, 513, 1006, 2468, 13, 14, 1794, 1795, 1796, 1013, - 93, 26, 524, 3492, 244, 1945, 226, 32, 1819, 370, - 1734, 370, 1869, 240, 868, 274, 2052, 3180, 244, 1851, - 59, 3100, 959, 1855, 137, 5, 1858, 375, 376, 868, - 3308, 2486, 868, 868, 1860, 972, 925, 1761, 868, 119, - 868, 978, 979, 108, 1869, 3080, 868, 984, 868, 173, - 987, 988, 272, 990, 991, 992, 993, 1781, 868, 4, - 1742, 868, 1786, 868, 9, 973, 973, 868, 868, 1006, - 868, 868, 2389, 1006, 868, 868, 1013, 226, 1869, 868, - 1013, 868, 868, 1006, 370, 3366, 513, 448, 3369, 448, - 1013, 365, 366, 202, 1031, 1032, 1033, 524, 501, 502, - 503, 1006, 505, 506, 507, 508, 509, 510, 1013, 509, - 173, 352, 137, 1006, 1772, 1052, 516, 2244, 338, 1777, - 1013, 245, 172, 272, 274, 2141, 206, 2602, 2144, 279, - 370, 26, 171, 514, 1071, 1876, 4, 32, 1087, 1880, - 743, 9, 1883, 377, 370, 1082, 1083, 1084, 2786, 1086, - 1087, 2994, 1089, 514, 11, 514, 202, 2310, 208, 2195, - 4, 2272, 448, 1933, 147, 9, 3245, 377, 512, 389, - 514, 30, 516, 26, 224, 251, 342, 1089, 161, 32, - 293, 1118, 245, 166, 234, 3466, 336, 2253, 3322, 46, - 26, 478, 272, 420, 274, 422, 32, 1988, 1135, 1136, - 13, 14, 1168, 1169, 1886, 1171, 1168, 1169, 448, 1171, - 3330, 3331, 416, 500, 515, 381, 1898, 518, 342, 1009, - 512, 448, 448, 80, 516, 1015, 85, 514, 514, 478, - 433, 451, 2131, 1170, 217, 94, 1869, 1174, 1175, 374, - 389, 354, 137, 356, 2014, 377, 1928, 1184, 1185, 1186, - 416, 500, 1189, 1935, 237, 466, 859, 381, 2317, 118, - 132, 370, 1162, 3383, 2323, 514, 514, 132, 293, 25, - 26, 1208, 381, 386, 514, 314, 315, 316, 8, 342, - 1421, 11, 1423, 1424, 137, 15, 16, 159, 514, 1971, - 2443, 512, 416, 1975, 159, 516, 823, 824, 825, 1981, - 466, 137, 451, 286, 1241, 6, 512, 416, 166, 10, - 516, 361, 295, 1250, 13, 14, 46, 18, 381, 2089, - 420, 2003, 422, 53, 1224, 350, 420, 1004, 422, 354, - 380, 190, 33, 13, 14, 1014, 37, 1274, 2136, 1018, - 379, 514, 466, 2818, 203, 1022, 420, 2138, 422, 1026, - 80, 837, 838, 416, 840, 13, 14, 466, 114, 1296, - 514, 386, 26, 26, 507, 2700, 1295, 1295, 32, 32, - 514, 188, 189, 1295, 514, 1312, 1295, 416, 514, 74, - 2171, 2172, 515, 988, 1321, 518, 515, 13, 14, 518, - 2426, 26, 2224, 2429, 2226, 171, 515, 32, 293, 518, - 1312, 1338, 274, 466, 512, 3484, 514, 279, 515, 514, - 449, 518, 284, 515, 279, 145, 518, 515, 1355, 284, - 518, 460, 117, 515, 1361, 420, 518, 422, 1442, 1337, - 1337, 1445, 457, 2227, 515, 2229, 1450, 518, 500, 1453, - 293, 258, 259, 1355, 1458, 515, 176, 2200, 518, 2602, - 1338, 3469, 2568, 3471, 2570, 350, 514, 293, 2585, 354, - 3435, 444, 2298, 193, 515, 2584, 515, 518, 198, 518, - 514, 1408, 1409, 137, 137, 514, 3451, 1414, 875, 1416, - 877, 2569, 514, 1416, 1421, 1422, 1423, 1424, 13, 14, - 514, 386, 2616, 515, 3512, 515, 518, 350, 518, 1436, - 1437, 354, 137, 171, 515, 1442, 236, 518, 1445, 1442, - 514, 1416, 1445, 1450, 2633, 1452, 1453, 1450, 354, 1442, - 1453, 1458, 1445, 1416, 2583, 1458, 2585, 1450, 2473, 2474, - 1453, 3506, 497, 386, 223, 1458, 3511, 1442, 515, 515, - 1445, 518, 518, 402, 516, 1450, 405, 82, 1453, 1442, - 386, 1154, 1445, 1458, 13, 14, 289, 1450, 375, 376, - 1453, 291, 457, 435, 497, 1458, 516, 2451, 2452, 2453, - 435, 13, 14, 108, 446, 42, 170, 2476, 1515, 274, - 515, 446, 518, 518, 279, 3223, 37, 3225, 13, 14, - 2451, 2452, 2451, 515, 515, 2450, 518, 518, 515, 515, - 515, 518, 518, 518, 457, 8, 515, 177, 11, 518, - 1547, 1548, 15, 16, 13, 14, 19, 20, 21, 1556, - 1557, 457, 515, 13, 14, 518, 5, 1564, 2310, 293, - 293, 1544, 202, 328, 1571, 514, 1544, 1544, 173, 515, - 107, 515, 109, 294, 111, 515, 515, 1544, 518, 344, - 1544, 515, 1544, 1544, 518, 171, 2447, 2448, 293, 1596, - 514, 391, 59, 1600, 497, 3140, 1603, 202, 13, 14, - 240, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, - 1617, 2339, 13, 14, 1621, 1622, 350, 350, 417, 1626, - 354, 354, 515, 1630, 152, 518, 1633, 1634, 1635, 1636, - 1637, 1638, 1639, 1640, 1641, 1617, 3233, 1644, 515, 223, - 245, 518, 2345, 350, 1651, 350, 1653, 13, 14, 354, - 147, 172, 386, 386, 294, 1328, 1692, 1330, 2881, 2537, - 1692, 13, 14, 515, 161, 1672, 518, 515, 177, 166, - 518, 152, 515, 515, 2832, 518, 518, 126, 127, 40, - 445, 386, 2879, 515, 13, 14, 518, 208, 1695, 454, - 152, 2443, 515, 202, 515, 518, 152, 518, 498, 1706, - 1707, 13, 14, 224, 152, 505, 506, 507, 508, 509, - 510, 515, 1670, 234, 13, 14, 13, 14, 13, 14, - 217, 416, 171, 457, 457, 198, 13, 14, 13, 14, - 370, 240, 171, 1408, 1409, 1742, 514, 2560, 274, 1414, - 237, 2602, 13, 14, 1751, 89, 1753, 2499, 221, 13, - 14, 40, 457, 466, 2915, 2623, 365, 366, 2664, 365, - 366, 2955, 152, 2644, 480, 370, 365, 366, 152, 1751, - 516, 1753, 262, 263, 2676, 152, 381, 375, 376, 3433, - 420, 152, 422, 3437, 289, 294, 1793, 459, 460, 286, - 1797, 3446, 3447, 1800, 1801, 352, 2787, 3184, 295, 439, - 3478, 3479, 1135, 1136, 428, 445, 514, 171, 448, 515, - 514, 416, 514, 514, 418, 3038, 219, 224, 291, 299, - 514, 514, 224, 40, 224, 296, 235, 514, 5, 5, - 514, 1838, 324, 514, 439, 514, 514, 5, 5, 3493, - 361, 514, 5, 514, 5, 148, 1853, 9, 514, 514, - 2602, 477, 104, 1860, 1861, 301, 518, 518, 515, 380, - 3405, 466, 1869, 219, 386, 314, 315, 316, 40, 286, - 1834, 2732, 166, 166, 1958, 314, 315, 316, 284, 1886, - 1964, 59, 235, 1890, 1891, 514, 1893, 428, 93, 514, - 518, 1898, 1899, 1900, 1901, 1902, 1903, 1904, 428, 59, - 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, - 59, 420, 428, 422, 265, 1922, 1923, 3140, 428, 1926, - 108, 1928, 524, 221, 428, 428, 1933, 476, 1935, 152, - 379, 100, 377, 37, 274, 274, 445, 514, 42, 448, - 379, 390, 40, 2870, 274, 2697, 274, 444, 1955, 514, - 3337, 1958, 274, 1960, 198, 1958, 782, 1964, 784, 152, - 171, 1964, 3151, 412, 1971, 1958, 516, 416, 1975, 13, - 1977, 1964, 1979, 515, 1981, 515, 171, 416, 224, 518, - 2882, 2883, 515, 1958, 515, 473, 224, 514, 814, 1964, - 515, 515, 515, 3380, 514, 1958, 2003, 101, 535, 2727, - 449, 1964, 281, 540, 281, 518, 543, 2014, 2015, 2870, - 449, 460, 514, 839, 2875, 512, 516, 516, 515, 516, - 463, 460, 2774, 514, 39, 514, 9, 476, 501, 502, - 503, 514, 505, 506, 507, 508, 509, 510, 3029, 514, - 3009, 472, 514, 3430, 514, 426, 426, 2054, 11, 513, - 352, 500, 2059, 2060, 426, 518, 524, 518, 523, 514, - 279, 2922, 2923, 171, 1737, 514, 428, 514, 172, 180, - 2089, 162, 171, 3267, 1747, 514, 1749, 2084, 2085, 1752, - 518, 8, 2089, 515, 454, 1758, 217, 1760, 15, 16, - 518, 117, 19, 20, 21, 265, 2103, 389, 226, 2106, - 1773, 2108, 3208, 290, 208, 1778, 312, 518, 312, 1782, - 1783, 1784, 1785, 518, 1787, 1788, 180, 2124, 2125, 219, - 224, 126, 127, 2851, 2131, 226, 515, 2134, 514, 2881, - 234, 2134, 274, 226, 333, 287, 295, 40, 514, 466, - 514, 2134, 152, 152, 2151, 171, 972, 3, 2151, 152, - 476, 152, 152, 274, 514, 981, 289, 2164, 2151, 2134, - 3, 40, 289, 2915, 268, 59, 171, 171, 40, 11, - 166, 2134, 515, 515, 2181, 2182, 2151, 515, 515, 514, - 514, 180, 3405, 514, 166, 289, 3, 39, 2151, 3, - 515, 2198, 512, 2200, 512, 303, 428, 428, 428, 428, - 513, 515, 2209, 518, 1030, 515, 314, 315, 316, 516, - 314, 3408, 3118, 497, 523, 515, 497, 321, 171, 515, - 2227, 2228, 2229, 497, 1899, 1900, 1901, 1902, 1903, 1904, - 428, 514, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, - 1915, 1916, 2994, 515, 514, 2227, 2228, 2229, 515, 515, - 515, 514, 514, 155, 791, 249, 514, 361, 473, 2266, - 40, 59, 518, 503, 499, 2272, 1033, 3128, 3129, 290, - 1096, 379, 290, 518, 243, 59, 380, 303, 451, 3140, - 1106, 59, 428, 274, 265, 2304, 3038, 2990, 314, 315, - 316, 152, 514, 202, 2293, 2293, 428, 152, 1124, 152, - 514, 2293, 428, 2310, 2293, 428, 428, 1133, 416, 314, - 315, 316, 515, 281, 281, 40, 352, 514, 518, 515, - 476, 2328, 287, 289, 2331, 40, 177, 152, 279, 515, - 171, 514, 514, 870, 515, 515, 515, 59, 2345, 185, - 166, 449, 3210, 80, 2351, 449, 512, 143, 198, 2331, - 454, 202, 460, 379, 3194, 171, 3196, 3235, 515, 8, - 515, 515, 11, 514, 291, 515, 15, 16, 476, 2351, - 19, 20, 21, 514, 379, 515, 524, 171, 300, 518, - 917, 515, 2389, 3206, 358, 390, 2389, 36, 3140, 240, - 416, 290, 500, 180, 514, 932, 933, 934, 935, 515, - 152, 518, 515, 175, 514, 439, 514, 412, 515, 2084, - 2085, 416, 515, 515, 2389, 40, 40, 514, 86, 3209, - 516, 2428, 3212, 449, 514, 2428, 2389, 3396, 515, 518, - 514, 454, 518, 3339, 460, 171, 2443, 2514, 514, 198, - 515, 1208, 475, 294, 449, 515, 515, 513, 985, 460, - 476, 513, 2459, 518, 515, 460, 515, 2476, 2465, 2466, - 3348, 3329, 313, 515, 515, 289, 503, 59, 515, 2476, - 515, 476, 515, 2146, 500, 515, 204, 117, 476, 40, - 2487, 226, 514, 2490, 88, 2492, 191, 279, 514, 279, - 2509, 40, 2499, 2500, 516, 500, 2503, 2504, 40, 516, - 3323, 2508, 2509, 516, 516, 513, 503, 428, 2515, 514, - 516, 60, 274, 107, 516, 476, 40, 9, 428, 370, - 314, 315, 316, 2530, 7, 8, 377, 516, 1354, 1296, - 13, 516, 1358, 2540, 289, 515, 19, 516, 516, 516, - 23, 2560, 25, 26, 3405, 2528, 516, 30, 31, 32, - 2528, 2528, 35, 2560, 516, 38, 39, 106, 516, 42, - 516, 2528, 45, 46, 2528, 515, 2528, 2528, 516, 420, - 2534, 422, 221, 516, 501, 502, 503, 516, 505, 506, - 507, 508, 509, 510, 516, 379, 516, 516, 439, 513, - 516, 351, 2599, 516, 445, 2602, 2603, 448, 2605, 516, - 516, 516, 516, 516, 516, 516, 89, 90, 516, 515, - 2617, 518, 2619, 514, 514, 335, 514, 2599, 514, 102, - 515, 2603, 416, 2605, 107, 108, 109, 110, 111, 514, - 518, 59, 515, 198, 191, 513, 518, 459, 91, 515, - 344, 514, 291, 40, 2643, 2643, 152, 2320, 516, 3377, - 515, 2643, 201, 3405, 2643, 449, 40, 1194, 124, 152, - 40, 515, 40, 366, 366, 26, 460, 515, 40, 514, - 1207, 32, 454, 309, 514, 2639, 60, 514, 514, 40, - 518, 279, 476, 190, 248, 454, 439, 2694, 74, 292, - 2697, 1228, 74, 514, 9, 80, 515, 515, 368, 60, - 2719, 250, 2666, 514, 513, 2669, 500, 2714, 2715, 515, - 2794, 260, 2719, 513, 59, 2722, 93, 133, 503, 2722, - 514, 272, 106, 272, 40, 439, 289, 515, 514, 459, - 292, 514, 8, 292, 515, 11, 515, 204, 515, 15, - 16, 289, 2749, 289, 515, 106, 122, 386, 1515, 40, - 451, 365, 148, 25, 1291, 304, 2763, 36, 365, 297, - 1297, 2768, 2769, 868, 2875, 2586, 2773, 2774, 2222, 60, - 46, 2778, 1033, 0, 2781, 2782, 137, 53, 1759, 2786, - 2787, 2599, 1671, 2790, 2265, 1803, 2292, 2794, 3301, 2808, - 1232, 2794, 2351, 20, 2801, 783, 23, 2990, 3354, 3461, - 3111, 2794, 3409, 2635, 80, 3418, 3454, 356, 1195, 3169, - 2215, 38, 2228, 2655, 2578, 106, 26, 201, 3407, 2794, - 47, 3416, 32, 2212, 2605, 3404, 1292, 2539, 2503, 2504, - 40, 2794, 381, 1320, 2334, 1661, 1860, 1338, 2845, 3299, - 201, 1608, 3237, 2538, 3380, 3333, 2853, 3483, 2528, 2198, - 60, 400, 501, 502, 503, 2164, 505, 506, 507, 508, - 509, 510, 89, 90, 91, 2872, 250, 1005, 1154, 145, - 1005, 1731, 1358, 1178, 2881, 102, 260, 2410, 3389, 2181, - 1695, 3310, 3198, 1730, 175, 23, 1177, 2151, 272, 250, - 2563, 2564, 1180, 2722, 1969, 3033, 106, 789, 983, 260, - 176, 2389, 1439, 800, 2388, 2435, 3132, 1984, 2915, 981, - 201, 272, 1869, 981, 981, 3314, 3313, 193, 2591, 2061, - 304, 981, 198, 981, 981, 981, 981, 137, 2466, 2016, - 2165, 2107, 293, 2606, 2607, 2608, 2609, 2610, 2611, 2612, - 2613, 2614, 2615, 304, 2104, 2063, 2483, 1208, 1670, 2801, - 1977, 102, 1437, -1, 2961, 2962, -1, -1, -1, 250, - 236, -1, -1, 1789, -1, -1, 515, -1, -1, 260, - -1, -1, 356, -1, -1, 1742, 1802, 1803, -1, -1, - 2962, 272, -1, 2990, -1, -1, 2993, 2994, -1, 350, - 3009, 201, -1, 354, -1, 356, -1, 381, -1, -1, - -1, -1, 3009, 40, -1, -1, -1, 2971, -1, -1, - -1, -1, -1, 304, -1, 291, 400, -1, -1, 2694, - 381, -1, 3029, 60, -1, 386, -1, -1, -1, -1, - -1, 3038, -1, -1, -1, 1296, 3043, -1, -1, 400, - 250, -1, -1, 1869, -1, -1, -1, 3054, 3055, 1875, - 260, 3058, 535, 3060, -1, -1, -1, 540, -1, -1, - 543, -1, 272, -1, -1, 356, -1, -1, 551, 106, - 107, -1, -1, -1, -1, -1, -1, -1, 3085, -1, - 117, -1, -1, 293, -1, -1, -1, -1, -1, -1, - 381, -1, -1, -1, 304, -1, 457, 8, -1, -1, - 11, -1, 3109, -1, 15, 16, -1, -1, 1033, 400, - -1, -1, -1, -1, -1, 391, -1, -1, -1, 1886, + 7, 0, 0, 47, 0, 73, 516, 0, 955, 16, + 0, 0, 895, 835, 0, 0, 23, 0, 904, 749, + 990, 0, 0, 881, 1235, 809, 970, 75, 76, 858, + 1691, 1196, 1223, 1032, 925, 920, 1221, 1156, 20, 741, + 38, 20, 20, 1417, 16, 77, 1573, 981, 981, 1209, + 1079, 981, 77, 981, 1654, 2140, 1190, 2142, 1465, 17, + 1198, 2313, 7, 2226, 2161, 959, 23, 1275, 75, 76, + 1986, 1201, 970, 2648, 1796, 46, 1297, 2171, 23, 0, + 39, 895, 2106, 897, 7, 899, 0, 0, 1226, 0, + 1123, 25, 26, 0, 0, 1128, 1607, 1608, 0, 2609, + 23, 2160, 100, 2663, 2609, 0, 26, 1987, 0, 805, + 0, 0, 1322, 999, 810, 2670, 748, 1087, 75, 76, + 0, 749, 742, 0, 0, 0, 2483, 2293, 0, 0, + 75, 76, 35, 0, 0, 0, 0, 2646, 2274, 2275, + 2276, 2565, 5, 2222, 0, 2569, 5, 0, 1658, 1709, + 979, 110, 75, 76, 5, 1711, 1814, 1053, 1054, 11, + 1927, 5, 13, 14, 16, 5, 13, 14, 5, 5, + 1815, 80, 5, 5, 1070, 5, 9, 13, 14, 5, + 114, 13, 14, 13, 14, 5, 5, 13, 14, 9, + 1134, 970, 5, 5, 5, 5, 4, 772, 982, 2982, + 5, 9, 2305, 9, 5, 2301, 172, 2299, 171, 5, + 5, 26, 2967, 3, 119, 5, 45, 32, 45, 13, + 14, 1960, 1961, 3, 4, 5, 1818, 55, 3, 9, + 2985, 9, 1971, 876, 876, 2314, 1975, 124, 63, 63, + 970, 11, 40, 1242, 100, 15, 16, 100, 122, 122, + 11, 2434, 1251, 1139, 2434, 16, 37, 1086, 74, 34, + 35, 107, 60, 147, 8, 23, 1210, 11, 871, 1213, + 1214, 15, 16, 190, 2821, 63, 4, 139, 5, 82, + 82, 9, 180, 2362, 2363, 46, 2365, 983, 3146, 289, + 93, 93, 802, 11, 295, 290, 287, 15, 16, 995, + 104, 117, 46, 295, 63, 2867, 0, 11, 106, 53, + 312, 15, 16, 1432, 74, 275, 107, 75, 76, 80, + 2937, 40, 137, 192, 30, 244, 20, 1106, 46, 23, + 107, 2416, 38, 217, 192, 183, 80, 117, 212, 365, + 850, 973, 165, 171, 38, 132, 1465, 132, 117, 2802, + 3277, 2804, 2527, 47, 2529, 1134, 278, 106, 1518, 388, + 1189, 289, 80, 1185, 1186, 119, 1953, 1954, 1955, 379, + 30, 171, 2579, 30, 40, 75, 180, 30, 30, 161, + 172, 75, 76, 77, 1057, 38, 38, 3341, 161, 416, + 1611, 172, 2528, 108, 149, 170, 3309, 172, 41, 3385, + 1073, 145, 2977, 201, 13, 14, 100, 2129, 168, 454, + 163, 295, 2922, 2988, 3076, 2578, 3078, 430, 406, 3174, + 64, 1279, 90, 1308, 71, 72, 122, 208, 478, 120, + 74, 1210, 176, 289, 1213, 1214, 289, 3235, 218, 3237, + 420, 137, 422, 224, 3371, 200, 1337, 3374, 272, 193, + 500, 2475, 250, 234, 198, 237, 175, 108, 274, 2553, + 240, 129, 260, 279, 237, 428, 479, 30, 272, 514, + 2979, 393, 132, 2680, 272, 132, 191, 230, 293, 3433, + 468, 272, 415, 126, 3470, 514, 355, 274, 514, 337, + 108, 451, 236, 3276, 352, 1524, 2575, 284, 2577, 284, + 323, 250, 358, 194, 286, 358, 304, 509, 518, 175, + 279, 260, 328, 213, 514, 3313, 308, 518, 366, 514, + 453, 3434, 85, 514, 1745, 279, 518, 3144, 344, 448, + 514, 94, 357, 357, 120, 350, 534, 3199, 2713, 354, + 503, 3468, 3104, 3090, 1187, 1187, 2729, 291, 514, 2729, + 3408, 456, 279, 516, 3007, 118, 454, 166, 356, 1162, + 444, 3123, 386, 2659, 2656, 1344, 1345, 454, 328, 357, + 416, 386, 1979, 2676, 1739, 1150, 0, 451, 451, 2106, + 361, 588, 1092, 381, 413, 26, 413, 1483, 1484, 3372, + 2506, 32, 1800, 370, 1423, 514, 240, 514, 357, 380, + 392, 3161, 400, 512, 463, 2372, 244, 516, 194, 1339, + 472, 2690, 1508, 403, 404, 1437, 588, 2177, 3373, 1321, + 476, 425, 2178, 476, 1326, 428, 428, 190, 428, 445, + 1332, 327, 1454, 2144, 478, 476, 3146, 478, 454, 307, + 203, 3146, 457, 2170, 265, 1836, 1856, 391, 2306, 512, + 163, 514, 517, 516, 2164, 514, 500, 1656, 510, 515, + 1871, 517, 515, 514, 517, 478, 2311, 514, 1889, 520, + 514, 3095, 1568, 1569, 514, 2838, 3100, 514, 514, 2845, + 1901, 514, 514, 520, 514, 445, 514, 500, 514, 464, + 396, 2430, 3049, 518, 514, 514, 137, 505, 506, 320, + 3275, 514, 514, 514, 514, 749, 1338, 513, 1328, 514, + 1931, 1339, 2964, 514, 1600, 1601, 1602, 1938, 514, 514, + 514, 1550, 1551, 3283, 2316, 505, 506, 505, 506, 3284, + 518, 1560, 370, 476, 1430, 505, 506, 507, 508, 509, + 510, 517, 749, 396, 396, 1574, 148, 454, 476, 510, + 258, 259, 800, 421, 498, 1976, 800, 500, 271, 1980, + 2819, 505, 506, 507, 508, 509, 510, 749, 117, 748, + 748, 3474, 500, 226, 1603, 464, 1984, 505, 506, 356, + 11, 26, 789, 1897, 11, 33, 1565, 2008, 2704, 507, + 508, 509, 510, 800, 177, 249, 59, 199, 1577, 515, + 1579, 2825, 518, 507, 508, 509, 510, 514, 3383, 386, + 448, 59, 3515, 881, 1928, 46, 848, 1490, 1551, 272, + 274, 1940, 2958, 848, 5, 1769, 1605, 1560, 835, 836, + 2417, 2418, 2419, 2420, 503, 1779, 518, 1510, 1782, 402, + 534, 190, 405, 800, 789, 1844, 2872, 516, 782, 80, + 784, 858, 293, 80, 2880, 800, 1009, 240, 2738, 3368, + 1979, 2741, 1015, 2743, 784, 2781, 789, 375, 376, 868, + 868, 1544, 868, 312, 856, 868, 514, 800, 868, 868, + 814, 1764, 868, 868, 509, 868, 2965, 274, 859, 868, + 868, 516, 137, 512, 853, 902, 903, 516, 3408, 906, + 907, 1411, 2624, 3408, 2626, 839, 5, 1854, 171, 350, + 514, 1858, 871, 354, 1861, 1948, 514, 3426, 3170, 3494, + 2130, 1623, 503, 1737, 202, 274, 108, 366, 1872, 1708, + 1709, 1822, 352, 514, 837, 838, 389, 840, 2057, 1797, + 1798, 1799, 1004, 3106, 177, 386, 274, 868, 2475, 53, + 1764, 279, 959, 37, 868, 868, 515, 868, 1006, 518, + 1022, 868, 868, 970, 1026, 1013, 868, 925, 377, 1863, + 1784, 978, 979, 868, 1872, 1789, 868, 984, 868, 868, + 987, 988, 2493, 990, 991, 992, 993, 370, 868, 3086, + 1769, 868, 868, 868, 973, 973, 868, 868, 451, 1006, + 1779, 868, 868, 1782, 868, 244, 1013, 240, 336, 3334, + 3335, 26, 2146, 132, 2148, 377, 457, 32, 119, 82, + 2394, 416, 26, 82, 1031, 1032, 1033, 433, 32, 173, + 93, 789, 244, 132, 93, 513, 970, 420, 173, 422, + 159, 515, 800, 1087, 518, 1052, 524, 981, 293, 1006, + 244, 314, 315, 316, 748, 749, 1013, 202, 244, 2250, + 159, 1006, 3387, 513, 1071, 448, 251, 244, 1013, 2277, + 509, 2793, 176, 1775, 524, 1082, 1083, 1084, 1780, 1086, + 1087, 2200, 2609, 1006, 1091, 3001, 132, 3250, 172, 193, + 1013, 466, 370, 1872, 198, 789, 1030, 2318, 40, 478, + 512, 245, 514, 381, 516, 206, 800, 1936, 26, 354, + 245, 356, 1119, 159, 32, 420, 379, 422, 60, 1091, + 2258, 500, 137, 478, 208, 823, 824, 825, 26, 1136, + 1137, 370, 236, 137, 32, 514, 1168, 1169, 416, 1171, + 224, 386, 1872, 1168, 1169, 500, 1171, 4, 515, 509, + 234, 518, 9, 416, 848, 274, 516, 1014, 370, 514, + 279, 1018, 1096, 1170, 106, 284, 2136, 1174, 1175, 13, + 14, 272, 1106, 274, 868, 274, 370, 1184, 1185, 1186, + 279, 512, 1189, 514, 370, 284, 449, 420, 466, 422, + 2019, 1125, 1879, 370, 374, 2325, 1883, 460, 342, 1886, + 1134, 2331, 1209, 1162, 512, 4, 4, 342, 516, 448, + 9, 9, 377, 8, 1993, 448, 11, 161, 514, 137, + 15, 16, 166, 11, 19, 20, 21, 15, 16, 2450, + 420, 514, 422, 279, 26, 1242, 448, 381, 284, 137, + 32, 36, 4, 514, 1251, 161, 381, 9, 1006, 166, + 166, 514, 512, 514, 448, 1013, 516, 515, 46, 201, + 518, 1422, 448, 1424, 1425, 2094, 1225, 420, 1275, 422, + 514, 448, 416, 837, 838, 514, 840, 361, 293, 973, + 226, 416, 2229, 2141, 2231, 515, 514, 391, 518, 293, + 1297, 515, 80, 237, 518, 514, 380, 1296, 2825, 171, + 2707, 515, 514, 2232, 518, 2234, 1313, 1296, 250, 514, + 1296, 1296, 1006, 2432, 514, 1322, 435, 2436, 260, 1013, + 514, 237, 466, 3486, 13, 14, 272, 446, 514, 507, + 272, 466, 1339, 13, 14, 350, 435, 514, 514, 354, + 515, 1313, 286, 518, 514, 137, 350, 446, 515, 1356, + 354, 518, 500, 3438, 1048, 1362, 171, 1339, 515, 1338, + 1338, 518, 304, 2575, 2143, 2577, 1060, 514, 3453, 515, + 286, 386, 518, 515, 497, 293, 518, 3471, 515, 3473, + 223, 518, 386, 2205, 1356, 342, 13, 14, 2609, 435, + 342, 516, 338, 1087, 1442, 293, 1444, 2176, 2177, 1447, + 446, 2592, 1409, 1410, 1452, 289, 2591, 1455, 1415, 1457, + 1417, 2576, 2623, 1461, 356, 1422, 1423, 1424, 1425, 2304, + 3514, 1355, 497, 3508, 381, 1359, 221, 516, 3513, 381, + 1437, 1438, 350, 13, 14, 1442, 354, 1444, 171, 381, + 1447, 515, 457, 389, 518, 1452, 515, 1454, 1455, 518, + 1457, 2480, 2481, 457, 1461, 2640, 354, 170, 400, 416, + 2590, 518, 2592, 873, 416, 875, 188, 189, 386, 171, + 515, 514, 1417, 518, 1168, 1169, 515, 1171, 515, 518, + 515, 518, 515, 518, 515, 1442, 515, 1444, 386, 518, + 1447, 13, 14, 515, 1417, 1452, 291, 1442, 1455, 1444, + 1457, 293, 1447, 294, 1461, 451, 3228, 1452, 3230, 466, + 1455, 1518, 1457, 2483, 466, 515, 1461, 515, 518, 1442, + 518, 1444, 59, 2457, 1447, 2458, 2459, 2460, 2458, 1452, + 2458, 2459, 1455, 514, 1457, 177, 258, 259, 1461, 457, + 177, 417, 515, 1550, 1551, 518, 497, 515, 223, 1547, + 518, 1547, 1559, 1560, 1547, 13, 14, 1547, 350, 457, + 1567, 152, 354, 350, 1547, 202, 6, 1574, 1547, 1547, + 10, 152, 515, 515, 515, 518, 515, 518, 18, 518, + 152, 314, 315, 316, 515, 515, 515, 518, 518, 518, + 13, 14, 1599, 33, 386, 152, 1603, 37, 240, 1606, + 13, 14, 152, 240, 1611, 1612, 1613, 1614, 1615, 1616, + 1617, 1618, 1619, 1620, 13, 14, 40, 1624, 1625, 3146, + 2350, 515, 1629, 416, 518, 515, 1633, 515, 518, 1636, + 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 3238, 514, + 1647, 274, 2344, 40, 1338, 466, 379, 1654, 1620, 1656, + 89, 82, 515, 375, 376, 518, 152, 294, 2544, 1417, + 515, 515, 1694, 518, 518, 457, 480, 2888, 1675, 1694, + 152, 313, 13, 14, 2839, 2454, 2455, 108, 13, 14, + 516, 5, 152, 416, 1442, 152, 1444, 13, 14, 1447, + 1697, 1673, 13, 14, 1452, 2886, 289, 1455, 352, 1457, + 428, 1708, 1709, 1461, 13, 14, 501, 502, 503, 514, + 505, 506, 507, 508, 509, 510, 449, 505, 506, 507, + 508, 509, 510, 13, 14, 13, 14, 460, 370, 171, + 1664, 13, 14, 13, 14, 377, 2683, 514, 1745, 13, + 14, 514, 173, 13, 14, 2567, 515, 1754, 1442, 1756, + 1444, 2962, 418, 1447, 13, 14, 514, 8, 1452, 219, + 2651, 1455, 2922, 1457, 15, 16, 299, 1461, 19, 20, + 21, 202, 2630, 13, 14, 3436, 365, 366, 420, 3440, + 422, 514, 1754, 420, 1756, 422, 13, 14, 2673, 1796, + 13, 14, 224, 1800, 514, 2794, 1803, 1804, 365, 366, + 37, 296, 126, 127, 224, 42, 448, 224, 445, 365, + 366, 448, 365, 366, 245, 514, 3190, 262, 263, 40, + 375, 376, 514, 3044, 459, 460, 3448, 3449, 3480, 3481, + 2609, 235, 5, 8, 3495, 5, 11, 1844, 1136, 1137, + 15, 16, 1840, 514, 19, 20, 21, 171, 324, 1856, + 514, 514, 514, 1547, 5, 5, 1863, 1864, 1792, 514, + 5, 514, 5, 148, 101, 1872, 514, 9, 514, 477, + 104, 1805, 1806, 301, 518, 518, 515, 40, 386, 219, + 166, 3408, 1889, 286, 284, 166, 1893, 1894, 59, 1896, + 235, 514, 428, 514, 1901, 1902, 1903, 1904, 1905, 1906, + 1907, 93, 518, 1910, 1911, 1912, 1913, 1914, 1915, 1916, + 1917, 1918, 1919, 428, 1962, 59, 428, 265, 1925, 1926, + 1968, 74, 1929, 59, 1931, 3146, 428, 80, 108, 1936, + 524, 1938, 1626, 2877, 221, 172, 428, 428, 1872, 370, + 93, 476, 2889, 2890, 1878, 152, 100, 377, 198, 274, + 381, 1958, 274, 514, 274, 1962, 40, 1964, 274, 274, + 2739, 1968, 514, 152, 117, 171, 119, 3341, 516, 1976, + 13, 208, 3157, 1980, 515, 1982, 515, 1984, 171, 1986, + 518, 515, 224, 515, 515, 416, 515, 224, 515, 514, + 314, 315, 316, 473, 224, 514, 8, 234, 281, 11, + 1694, 2008, 281, 15, 16, 1962, 147, 514, 439, 518, + 3384, 1968, 2019, 2020, 463, 516, 514, 1962, 39, 516, + 161, 514, 472, 1968, 147, 166, 1033, 514, 514, 514, + 514, 268, 2734, 9, 46, 466, 426, 426, 161, 1962, + 291, 53, 13, 166, 11, 1968, 3016, 352, 19, 513, + 2094, 524, 2059, 206, 426, 379, 518, 2064, 2065, 3433, + 31, 3272, 518, 514, 521, 279, 390, 514, 80, 428, + 180, 162, 171, 454, 45, 46, 217, 314, 515, 217, + 518, 265, 2089, 2090, 321, 518, 389, 2094, 412, 226, + 290, 518, 416, 312, 217, 3214, 237, 312, 2877, 518, + 180, 2108, 219, 2882, 2111, 515, 2113, 514, 226, 274, + 226, 333, 295, 287, 237, 466, 291, 152, 514, 3, + 514, 274, 2129, 2130, 361, 449, 279, 1134, 514, 2136, + 152, 40, 2139, 145, 1828, 152, 460, 108, 152, 476, + 1033, 152, 274, 380, 3, 286, 1840, 147, 40, 2156, + 2929, 2930, 476, 59, 295, 289, 2858, 11, 289, 40, + 515, 161, 2169, 286, 176, 171, 166, 166, 515, 515, + 180, 515, 295, 166, 3, 328, 500, 39, 514, 2186, + 2187, 193, 2139, 514, 514, 3, 198, 3408, 515, 512, + 514, 344, 428, 512, 2139, 428, 2203, 428, 2205, 2156, + 428, 513, 1209, 521, 1962, 515, 497, 2214, 515, 515, + 1968, 2156, 449, 515, 518, 117, 2139, 217, 516, 497, + 3411, 515, 515, 515, 236, 2232, 2233, 2234, 497, 171, + 428, 515, 155, 2156, 249, 8, 40, 237, 11, 3124, + 59, 514, 15, 16, 473, 503, 19, 20, 21, 514, + 501, 502, 503, 514, 505, 506, 507, 508, 509, 510, + 2232, 2233, 2234, 518, 2271, 2309, 514, 2997, 1962, 171, + 2277, 514, 290, 46, 1968, 499, 59, 290, 243, 291, + 53, 59, 451, 518, 265, 274, 286, 152, 428, 514, + 1297, 202, 445, 428, 152, 295, 152, 281, 428, 2298, + 428, 454, 428, 444, 281, 2239, 2313, 80, 40, 2298, + 515, 2318, 2298, 2298, 352, 514, 1209, 514, 287, 515, + 476, 444, 40, 518, 152, 289, 501, 502, 503, 2336, + 505, 506, 507, 508, 509, 510, 279, 515, 171, 515, + 59, 2313, 514, 2350, 185, 166, 514, 80, 515, 2356, + 512, 515, 143, 198, 3240, 3134, 3135, 2291, 515, 171, + 515, 300, 358, 515, 524, 290, 515, 3146, 514, 180, + 518, 3200, 152, 3202, 175, 2309, 515, 439, 40, 391, + 40, 2139, 515, 86, 2356, 514, 454, 2394, 515, 512, + 3212, 515, 515, 516, 514, 514, 518, 518, 2156, 514, + 2094, 303, 515, 176, 1297, 516, 515, 515, 514, 171, + 515, 514, 314, 315, 316, 515, 2350, 518, 2112, 514, + 193, 475, 515, 198, 2358, 198, 2360, 2434, 515, 3399, + 2364, 3215, 2366, 3217, 2128, 513, 513, 518, 289, 2483, + 515, 515, 515, 2450, 444, 2139, 515, 503, 59, 2394, + 515, 460, 515, 2521, 515, 515, 476, 204, 3343, 2466, + 117, 40, 2156, 236, 514, 2472, 2473, 226, 88, 3352, + 191, 2394, 2516, 279, 279, 3333, 2483, 379, 40, 516, + 516, 428, 516, 516, 516, 516, 498, 2494, 516, 516, + 2497, 516, 2499, 505, 506, 507, 508, 509, 510, 2506, + 2507, 503, 428, 2510, 2511, 3327, 513, 515, 2515, 2516, + 515, 1518, 512, 516, 416, 2522, 516, 8, 291, 516, + 11, 516, 516, 2567, 15, 16, 516, 513, 516, 516, + 2537, 516, 274, 516, 516, 514, 516, 2535, 516, 2535, + 2547, 516, 2535, 2541, 516, 2535, 516, 449, 516, 107, + 516, 514, 2535, 7, 8, 46, 2535, 2535, 460, 13, + 2567, 516, 53, 516, 516, 19, 516, 516, 476, 23, + 515, 25, 26, 40, 476, 289, 30, 31, 32, 514, + 551, 35, 9, 351, 38, 39, 514, 514, 42, 80, + 335, 45, 46, 515, 518, 59, 40, 171, 500, 2606, + 518, 515, 2609, 2610, 1611, 2612, 198, 191, 513, 459, + 91, 518, 514, 344, 515, 2309, 60, 2624, 391, 2626, + 514, 75, 76, 40, 152, 1518, 516, 515, 124, 3408, + 152, 40, 515, 40, 2606, 515, 2394, 366, 2610, 366, + 2612, 514, 514, 40, 518, 454, 100, 514, 309, 2647, + 514, 2650, 0, 107, 108, 109, 110, 111, 279, 248, + 190, 2650, 106, 107, 2650, 2650, 454, 439, 514, 292, + 74, 74, 80, 117, 9, 2609, 515, 2675, 515, 3381, + 2678, 368, 2726, 514, 59, 176, 133, 513, 515, 513, + 503, 93, 272, 289, 2701, 439, 40, 2704, 514, 292, + 514, 292, 193, 459, 204, 515, 289, 198, 2642, 386, + 122, 289, 515, 515, 2721, 2722, 515, 451, 1611, 2726, + 365, 25, 2729, 148, 36, 498, 365, 297, 501, 502, + 503, 175, 505, 506, 507, 508, 509, 510, 1745, 2593, + 314, 315, 316, 868, 1762, 236, 151, 2227, 3242, 2756, + 3384, 2606, 100, 2801, 3337, 1863, 2545, 201, 3485, 2882, + 2339, 3358, 3463, 2770, 3117, 3412, 171, 3421, 2775, 2776, + 3456, 2815, 743, 2780, 2781, 1196, 3176, 2220, 2785, 2664, + 3410, 2788, 2789, 3419, 2233, 2217, 2793, 2794, 2585, 2483, + 2797, 2612, 3407, 1321, 2801, 8, 3306, 2297, 11, 147, + 291, 2808, 15, 16, 1294, 379, 250, 2356, 2997, 2203, + 2169, 2642, 1155, 161, 1005, 1005, 260, 1178, 166, 1733, + 1177, 2415, 2516, 171, 3393, 2186, 1697, 3315, 272, 3204, + 274, 1732, 180, 46, 23, 2156, 2729, 185, 1180, 3039, + 53, 2535, 416, 1974, 2801, 2852, 800, 2541, 789, 2394, + 2393, 2442, 1745, 2860, 3138, 1989, 2801, 3319, 126, 127, + 304, 1872, 3318, 2066, 2170, 2473, 2112, 80, 2109, 217, + 2021, 2805, 2879, 2567, 1438, 449, 983, 981, 2801, 981, + 2068, 2888, 1889, 981, 981, 981, 460, 981, 859, 237, + 2808, 981, 981, 2490, 1901, 2535, 3304, 783, 1806, 1982, + 391, 1673, 476, 171, 1339, 1359, 1674, 2546, 100, 314, + 315, 316, 356, 2270, -1, 2922, 1233, -1, -1, -1, + -1, -1, -1, -1, 1931, -1, 500, -1, -1, 171, + -1, 1938, 145, -1, -1, -1, -1, 381, 286, -1, + 514, 289, -1, -1, -1, -1, -1, 295, -1, -1, + -1, -1, -1, 2647, -1, -1, 400, 2964, 402, -1, + -1, 405, 2969, 176, -1, -1, 1033, -1, -1, 1976, + -1, -1, 3016, 1980, 379, -1, -1, -1, -1, 1986, + 193, 2675, 2980, -1, 2678, 198, -1, 335, -1, -1, + 2997, -1, 2964, 3000, 3001, -1, 1889, -1, -1, -1, + -1, 2008, -1, -1, -1, -1, -1, 498, 1901, 3016, + 358, 416, -1, -1, 505, 506, 507, 508, 509, 510, + -1, -1, 8, 236, -1, 11, -1, -1, -1, 15, + 16, -1, 2726, 19, 20, 21, -1, 3044, 1931, -1, + 2974, -1, 3049, 2801, 449, 1938, 314, 315, 316, -1, + 36, -1, -1, 3060, 3061, 460, -1, 3064, -1, 3066, + -1, 303, -1, 2997, -1, -1, -1, -1, 416, -1, + 514, 476, 314, 315, 316, -1, -1, -1, 291, -1, + -1, 535, -1, 1976, 3091, -1, 540, 1980, -1, 543, + -1, -1, -1, 1986, -1, 500, 444, 551, -1, 151, + -1, -1, -1, -1, -1, -1, 454, 2801, 3115, 514, + -1, 379, -1, -1, -1, 2008, -1, -1, -1, 171, + -1, 2815, 390, -1, -1, 473, -1, 475, 476, -1, + -1, -1, -1, -1, -1, -1, -1, 379, -1, 3146, + -1, -1, 1209, 3077, 412, 988, -1, -1, 416, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1898, 1669, 3140, 1671, 46, -1, -1, 175, -1, - 350, -1, 53, -1, 354, 1682, 356, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 1033, -1, - -1, 1928, -1, -1, 201, -1, -1, -1, 1935, 80, - -1, 381, 3179, 3180, 1033, -1, 386, 3184, 2853, 2852, - -1, 3184, -1, 1720, -1, -1, -1, 3194, -1, 3196, - 400, 3198, 3156, 3157, -1, 3202, -1, 3204, 3180, 3206, - -1, -1, -1, -1, 1971, -1, -1, -1, 1975, 3184, - 37, 3218, -1, 250, 1981, 42, 3223, -1, 3225, -1, - -1, 3184, 498, 260, -1, -1, 3233, -1, -1, 505, - 506, 507, 508, 509, 510, 272, 2003, 274, -1, 3246, - -1, -1, -1, -1, 3251, -1, -1, 457, -1, -1, - -1, -1, -1, -1, 1515, -1, -1, -1, 741, 742, - 743, -1, -1, -1, 3246, 176, -1, 304, -1, -1, - 3234, -1, 3236, -1, 101, -1, 1813, 1814, 1815, 1816, - -1, 1818, 193, 1208, -1, -1, -1, 198, -1, -1, - -1, -1, -1, 3300, -1, -1, -1, -1, -1, 782, - 783, 784, -1, 3310, -1, -1, 789, 534, 791, 1033, - -1, -1, 3276, -1, -1, -1, 3323, 800, 2993, 356, - -1, 804, 805, -1, -1, 236, 809, 810, 3292, -1, - 3337, -1, 3296, 1208, 3337, -1, -1, -1, -1, -1, - 823, 824, 825, -1, 381, 172, -1, 1608, 3355, 1208, - -1, -1, -1, 180, 837, 838, -1, 840, -1, -1, - -1, -1, 3337, 400, 3, 402, 5, -1, 405, -1, - 853, 1296, -1, 3380, 3337, -1, 859, 3380, -1, -1, - 291, 208, -1, -1, -1, -1, -1, 870, -1, 3396, - 873, -1, -1, -1, -1, 0, -1, 224, 3405, -1, - 3407, -1, -1, -1, -1, 3380, -1, 234, 2234, -1, - -1, -1, 1949, -1, -1, -1, -1, 3380, -1, -1, - -1, 1296, -1, 3430, -1, 3407, -1, 3430, -1, 68, - 69, -1, -1, -1, 917, 918, -1, 1296, 3445, 3446, - 3447, 268, -1, -1, -1, -1, -1, 3120, -1, 932, - 933, 934, 935, 936, -1, 3430, -1, -1, 3422, -1, - 2286, -1, 289, -1, -1, 3472, 949, 3430, 3141, 3142, - 109, 110, -1, -1, 113, 114, -1, 514, 2304, -1, - 391, 1742, -1, -1, 1208, 3449, -1, 314, -1, -1, - -1, 37, -1, 3166, 321, 100, 42, -1, -1, 982, - 983, -1, 985, -1, -1, 988, 3513, -1, -1, -1, - -1, 994, 995, -1, -1, -1, -1, 1000, -1, 2345, - -1, 748, 749, 1006, -1, -1, -1, 2353, -1, 2355, - 1013, -1, -1, 2359, 361, 2361, -1, -1, -1, -1, - 1023, -1, 147, 2310, -1, -1, -1, 1030, -1, 188, - 189, -1, 13, 380, -1, 101, 161, 1040, 19, -1, - -1, 166, 789, -1, -1, -1, 171, -1, -1, -1, - 31, -1, 1296, 800, -1, 180, -1, -1, -1, -1, - 185, -1, -1, -1, 45, 46, -1, 498, -1, -1, - 1515, -1, -1, -1, 505, 506, 507, 508, 509, 510, - -1, -1, -1, -1, -1, -1, -1, -1, 1091, -1, - -1, -1, 217, 252, 253, 254, 255, 256, 257, 258, - 259, 848, 449, 262, 263, 1886, 172, 454, -1, 151, - -1, -1, 237, -1, -1, -1, -1, 1898, -1, -1, - 1515, 868, -1, -1, -1, -1, -1, 108, -1, 171, - -1, -1, 8, -1, 1137, 11, 1515, 1140, -1, 15, - 16, -1, 208, 19, 20, 21, -1, 1928, -1, -1, - -1, 1154, 1155, -1, 1935, -1, 2443, -1, 224, 1162, - 36, 286, -1, 1608, 289, -1, -1, -1, 234, -1, - 295, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1184, -1, -1, -1, -1, -1, -1, -1, -1, - 1971, 1194, 1195, -1, 1975, 55, -1, -1, -1, -1, - 1981, -1, 268, -1, 1207, -1, -1, -1, 3401, -1, - 335, -1, 2499, 1608, -1, -1, 375, 376, -1, -1, - -1, 1224, 2003, 289, -1, 1228, 973, -1, -1, 1608, - 1233, -1, -1, 358, -1, 74, -1, 2294, -1, -1, - -1, 80, 102, -1, -1, -1, -1, -1, 314, -1, - 2307, 2308, 2309, -1, 93, 321, 2602, -1, -1, 1006, - -1, -1, -1, 123, -1, 2322, 1013, -1, 2325, -1, - -1, 1515, 314, 315, 316, -1, 2333, -1, 117, -1, - 119, 141, -1, -1, -1, 145, 1289, -1, 1291, 2635, - -1, 416, -1, -1, 1297, 361, -1, 1742, -1, -1, - -1, 1048, -1, -1, -1, -1, -1, 167, 1311, -1, - 170, 470, 471, 1060, 380, 2602, -1, 1320, -1, 444, - -1, -1, 1325, -1, 1327, 1328, 186, 1330, 1331, 454, - -1, -1, -1, -1, -1, 494, 495, 379, -1, -1, - 1087, -1, -1, -1, -1, 221, -1, 1742, 473, -1, - 475, 476, -1, -1, -1, 1358, -1, -1, -1, -1, - 2417, 2418, 2419, 1742, 1608, -1, -1, 206, -1, -1, - -1, -1, -1, -1, 416, -1, -1, -1, 2724, -1, - -1, -1, -1, 449, -1, -1, 8, 512, -1, 11, - 515, 516, 517, 15, 16, -1, -1, 19, 20, 21, - -1, -1, -1, -1, -1, 1408, 1409, 449, -1, -1, - 2697, 1414, -1, 1416, 36, 291, -1, -1, 460, 279, - -1, 1168, 1169, -1, 1171, -1, 1429, 287, 1431, 1432, - -1, -1, -1, -1, 476, 274, 1439, -1, -1, 1442, - 279, 1886, 1445, -1, -1, -1, -1, 1450, -1, 309, - 1453, -1, 2798, 1898, -1, 1458, -1, 1460, 500, 1462, + -1, -1, -1, 3170, 512, 3163, 3164, 515, 516, 517, + -1, -1, -1, -1, 416, -1, -1, -1, 391, 3186, + -1, 449, -1, 3190, 1155, -1, -1, -1, -1, -1, + -1, -1, 460, 3200, -1, 3202, -1, 3204, 3170, -1, + -1, 3208, -1, 3210, -1, 3212, -1, 449, 476, -1, + -1, -1, 3146, -1, -1, -1, 3223, -1, 460, -1, + -1, 3228, -1, 3230, -1, -1, -1, -1, -1, -1, + 1297, 3238, 500, -1, 476, 221, -1, -1, -1, -1, + -1, 3239, -1, 3241, 3251, 3190, 514, 1033, -1, 3256, + -1, -1, -1, -1, -1, -1, -1, -1, 500, -1, + -1, -1, 314, 315, 316, -1, -1, 3190, -1, -1, + -1, -1, 514, -1, -1, -1, -1, -1, -1, 3251, + -1, -1, -1, -1, 3282, 498, 2980, 741, 742, 743, + -1, -1, 505, 506, 507, 508, 509, 510, 3305, -1, + 3298, -1, -1, -1, 3302, 291, -1, -1, 3315, -1, + -1, 2318, -1, 177, -1, -1, -1, -1, -1, -1, + 3327, -1, 3016, -1, -1, -1, -1, 379, 782, 783, + 784, -1, -1, -1, 3341, 789, -1, 791, 202, 3273, + -1, 1184, -1, -1, -1, -1, 800, -1, -1, -1, + 804, 805, 3359, -1, -1, 809, 810, -1, 1329, -1, + 1331, -1, -1, -1, 416, -1, -1, -1, -1, 823, + 824, 825, -1, -1, -1, -1, 240, 3384, -1, -1, + -1, -1, 55, 837, 838, -1, 840, -1, -1, -1, + -1, -1, 3399, -1, -1, -1, 3341, 449, -1, 853, + -1, 3408, -1, 3410, -1, 859, -1, -1, 460, -1, + -1, -1, -1, -1, -1, -1, -1, 871, 3341, -1, + -1, -1, -1, 1209, 476, 2318, 3433, 3425, -1, 102, + 294, 885, 3190, -1, -1, 40, -1, -1, 3410, 3384, + 3447, 3448, 3449, 2450, -1, -1, -1, -1, 500, -1, + 123, 1518, -1, 3451, 0, 60, -1, -1, -1, -1, + -1, 3384, 514, 917, 918, -1, -1, 3474, 141, 3163, + 3164, -1, 145, -1, 3408, 929, -1, -1, -1, 933, + 934, 935, 936, -1, -1, -1, -1, -1, 3433, -1, + -1, -1, -1, -1, 167, 949, 988, 170, -1, 2506, + -1, 106, -1, -1, -1, -1, 370, -1, 3515, -1, + 3433, 1297, -1, 186, -1, 501, 502, 503, -1, 505, + 506, 507, 508, 509, 510, -1, -1, -1, 982, 983, + -1, 985, -1, -1, 988, -1, -1, -1, -1, -1, + 994, 995, -1, -1, 1611, 3239, 1000, 3241, -1, -1, + -1, -1, 1006, -1, 100, -1, 420, 2450, 422, 1013, + -1, -1, 13, -1, -1, -1, 1409, 1410, 19, 1023, + 175, -1, 1415, -1, -1, 439, 1030, -1, -1, -1, + 31, 445, -1, 3341, 448, -1, 1040, -1, 3282, -1, + -1, -1, -1, -1, 45, 46, 201, -1, -1, -1, + -1, 147, 2609, -1, 3298, -1, 279, -1, 3302, -1, + -1, -1, -1, 2506, 287, 161, -1, -1, -1, -1, + 166, -1, -1, -1, -1, 171, 3384, -1, -1, -1, + -1, -1, -1, -1, 180, 1089, 309, -1, -1, 185, + -1, -1, -1, -1, -1, 250, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 260, -1, 108, -1, -1, + -1, -1, 988, 336, -1, 8, -1, 272, 11, -1, + -1, 217, 15, 16, -1, 3433, -1, -1, 1745, -1, + -1, -1, -1, 1175, 1138, -1, 1140, -1, -1, -1, + -1, 237, 1184, -1, -1, -1, -1, 2704, -1, 304, + -1, 1155, 1156, 46, -1, -1, -1, -1, 1162, -1, + 53, -1, -1, -1, -1, -1, 2609, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 514, -1, 151, -1, 336, -1, -1, -1, - -1, -1, -1, 1928, -1, -1, -1, 2774, -1, 328, - 1935, 1886, -1, -1, 171, -1, -1, 2554, 1742, -1, - -1, -1, -1, 1898, -1, 344, -1, 1886, -1, 8, - -1, -1, 11, -1, -1, -1, 15, 16, -1, 1898, - 19, 20, 21, -1, -1, -1, 1971, -1, -1, 2310, - 1975, -1, -1, 1928, -1, -1, 1981, -1, -1, -1, - 1935, -1, -1, -1, -1, -1, -1, -1, -1, 1928, - -1, -1, -1, -1, -1, -1, 1935, -1, 2003, -1, - -1, -1, -1, -1, -1, -1, -1, 1570, -1, -1, - 551, -1, -1, -1, -1, -1, 1971, -1, 1581, -1, - 1975, -1, -1, -1, -1, -1, 1981, -1, 2645, -1, - 1337, -1, 1971, -1, 2881, -1, 1975, -1, -1, 221, - -1, -1, 1981, -1, -1, -1, 445, -1, 2003, -1, - -1, -1, -1, -1, -1, 454, -1, 1620, -1, -1, - -1, 2967, -1, -1, 2003, 501, 502, 503, 2915, 505, - 506, 507, 508, 509, 510, -1, -1, 314, 315, 316, - 8, -1, 1886, 11, 2990, -1, -1, 15, 16, -1, - 2707, 2708, 2709, 2710, 1898, -1, -1, -1, -1, -1, - -1, -1, 2443, -1, 1667, -1, 1669, -1, 1671, 291, - -1, -1, -1, -1, -1, -1, -1, -1, 46, 1682, - 1683, -1, -1, -1, 1928, 53, -1, -1, -1, -1, - -1, 1935, 1695, -1, -1, 1442, -1, -1, 1445, 198, - -1, -1, 379, 1450, -1, -1, 1453, 2994, -1, -1, - -1, 1458, 80, -1, -1, -1, -1, 1720, 2499, 1722, - -1, -1, 221, -1, -1, 3071, -1, 1971, -1, -1, - -1, 1975, -1, 1736, 1737, -1, -1, 1981, -1, 416, - -1, -1, -1, -1, 1747, 1748, 1749, 1750, -1, 1752, - -1, 3038, -1, -1, -1, 1758, -1, 1760, -1, 2003, - -1, 742, 743, -1, -1, -1, -1, -1, -1, 1772, - 1773, -1, 449, -1, 1777, 1778, -1, 145, -1, 1782, - 1783, 1784, 1785, 460, 1787, 1788, -1, -1, -1, -1, - -1, -1, 291, -1, 3140, -1, -1, 1544, -1, 476, - -1, 1804, 2859, -1, -1, -1, -1, -1, 176, -1, - 1813, 1814, 1815, 1816, 1817, 1818, -1, -1, -1, -1, - -1, 2602, -1, 500, -1, 193, -1, -1, -1, 1832, - 198, -1, -1, -1, -1, -1, -1, 514, -1, -1, - -1, -1, -1, -1, -1, 1848, -1, -1, -1, -1, - -1, -1, -1, 3140, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2310, -1, -1, 236, -1, - -1, -1, -1, -1, -1, -1, 1623, -1, 859, 501, - 502, 503, -1, 505, 506, 507, 508, 509, 510, -1, - -1, -1, -1, -1, -1, -1, 1899, 1900, 1901, 1902, - 1903, 1904, -1, -1, 1907, 1908, 1909, 1910, 1911, 1912, - 1913, 1914, 1915, 1916, -1, 2310, 2697, -1, -1, -1, - -1, -1, 3268, 291, -1, -1, -1, -1, -1, -1, - -1, 2310, -1, -1, 1937, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1692, 1949, -1, -1, -1, - -1, -1, -1, -1, -1, 1958, -1, -1, -1, -1, - -1, 1964, 8, -1, -1, 11, 1969, -1, -1, 15, - 16, 1974, -1, 19, 20, 21, -1, -1, -1, -1, - 1983, 1984, -1, -1, -1, -1, -1, -1, -1, -1, - 36, -1, -1, 2774, -1, -1, -1, -1, 2443, -1, - -1, -1, 501, 502, 503, -1, 505, 506, 507, 508, - 509, 510, -1, -1, -1, -1, -1, -1, -1, 1000, - -1, -1, -1, 391, -1, 8, -1, -1, 11, -1, - -1, -1, 15, 16, -1, -1, -1, -1, -1, -1, - -1, -1, 1023, -1, -1, -1, -1, -1, 2443, 2052, - -1, -1, -1, 2056, 2499, -1, -1, -1, 2061, 3405, - -1, -1, -1, 46, 2443, -1, 2310, -1, -1, -1, - 53, -1, -1, -1, -1, -1, -1, -1, 1825, -1, - -1, 2084, 2085, -1, -1, -1, -1, 1834, -1, -1, - -1, -1, -1, -1, -1, -1, 3442, 80, 2101, -1, - 2881, -1, -1, 3160, 2499, -1, -1, -1, -1, -1, - 1091, -1, -1, -1, -1, -1, -1, -1, 3405, -1, - 2499, -1, -1, -1, 3181, -1, -1, -1, -1, -1, - 498, 2134, -1, -1, 2915, -1, -1, 505, 506, 507, - 508, 509, 510, 2146, -1, -1, -1, -1, 2151, -1, - -1, -1, 2155, -1, -1, -1, -1, 2602, -1, -1, - -1, -1, 145, 8, -1, -1, 11, -1, -1, -1, - 15, 16, -1, 1154, 1155, 221, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3244, -1, -1, - -1, -1, 2195, 176, -1, 2198, -1, -1, 2201, 2443, - -1, 46, -1, -1, -1, -1, -1, 2602, 53, -1, - 193, 1958, -1, 2994, 2217, 198, -1, 1964, 3275, -1, - -1, -1, -1, 2602, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 80, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 291, -1, -1, -1, -1, - -1, -1, 2697, 236, -1, 2499, -1, 3038, -1, -1, + 1184, 3425, 1518, -1, -1, -1, -1, 80, -1, -1, + 286, 1195, 1196, 289, -1, -1, -1, -1, -1, 295, + -1, 356, -1, -1, 1208, -1, -1, 3451, -1, -1, + 0, -1, -1, -1, -1, -1, -1, -1, -1, 1740, + -1, 1225, -1, -1, 2781, 1229, 381, -1, -1, 1750, + 1234, 1752, -1, -1, 1755, -1, -1, -1, -1, 335, + 1761, -1, 1763, -1, -1, 400, -1, -1, -1, -1, + -1, -1, 145, -1, -1, 1776, -1, -1, -1, 1652, + 1781, 2704, 358, -1, 1785, 1786, 1787, 1788, -1, 1790, + 1791, -1, 1889, -1, -1, 1611, -1, -1, -1, -1, + -1, -1, -1, 176, 1901, -1, 1290, -1, 1292, -1, + -1, -1, -1, -1, -1, -1, -1, 1301, -1, -1, + 193, -1, -1, -1, 1697, 198, -1, -1, 1312, -1, + 100, -1, -1, -1, 1931, -1, -1, 1321, -1, -1, + 416, 1938, 1326, -1, 1328, 1329, -1, 1331, 1332, -1, + -1, 2888, -1, -1, 42, -1, -1, -1, 2781, -1, + -1, -1, -1, 236, -1, -1, -1, -1, 444, -1, + -1, -1, -1, -1, -1, 1359, -1, 147, 454, 1976, + -1, -1, -1, 1980, -1, 2922, -1, 1409, 1410, 1986, + -1, 161, -1, 1415, -1, -1, 166, 473, -1, 475, + 476, 171, -1, -1, -1, -1, -1, -1, -1, -1, + 180, 2008, -1, -1, -1, 185, -1, -1, 291, 107, + -1, 109, -1, 111, -1, 1409, 1410, 37, -1, 1745, + -1, 1415, 42, 1417, -1, -1, 512, -1, -1, 515, + 516, 517, -1, -1, -1, -1, 1430, 217, 1432, 1433, + -1, -1, -1, -1, 1033, -1, 1440, -1, 1442, -1, + 1444, -1, -1, 1447, 3001, 2888, -1, 237, 1452, -1, + -1, 1455, -1, 1457, -1, -1, -1, 1461, -1, 1463, + -1, 1465, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 101, -1, -1, -1, -1, -1, -1, -1, 2922, + -1, -1, -1, -1, -1, -1, -1, 3044, -1, -1, + -1, -1, -1, -1, -1, -1, 286, -1, 391, 289, + -1, -1, -1, -1, -1, 295, -1, -1, -1, 1902, + 1903, 1904, 1905, 1906, 1907, -1, -1, 1910, 1911, 1912, + 1913, 1914, 1915, 1916, 1917, 1918, 1919, -1, -1, -1, + -1, -1, -1, 1409, 1410, -1, -1, -1, 1033, 1415, + -1, -1, 172, -1, -1, 335, -1, -1, -1, -1, + 551, -1, -1, 1889, -1, -1, -1, -1, 3001, -1, + -1, -1, -1, -1, -1, 1901, -1, -1, 358, 1573, + -1, -1, -1, -1, -1, -1, -1, -1, 208, -1, + 1584, -1, -1, -1, -1, 1033, -1, -1, -1, 3146, + -1, -1, -1, -1, 224, 1931, -1, -1, -1, -1, + -1, 3044, 1938, -1, 234, 498, -1, -1, -1, -1, + 1209, -1, 505, 506, 507, 508, 509, 510, -1, 1623, + -1, -1, -1, -1, -1, -1, 416, -1, -1, -1, + 2151, -1, -1, -1, -1, -1, -1, -1, 268, -1, + 1976, -1, -1, -1, 1980, -1, -1, -1, -1, -1, + 1986, -1, -1, -1, 444, 1697, -1, -1, -1, 289, + -1, -1, -1, -1, 454, -1, 1670, -1, 1672, -1, + 1674, -1, 2008, -1, -1, -1, -1, -1, -1, -1, + 1684, 1685, -1, 473, 314, 475, 476, -1, -1, -1, + -1, 321, 177, 1697, -1, -1, 2089, 2090, 1297, -1, + -1, 2318, -1, 3146, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1209, -1, -1, 202, 1722, -1, + 1724, -1, 512, -1, -1, 515, 516, 517, -1, -1, + -1, 361, -1, -1, -1, 1739, 1740, -1, -1, -1, + -1, 742, 743, -1, -1, -1, 1750, 1751, 1752, 1753, + 380, 1755, -1, -1, -1, 240, -1, 1761, -1, 1763, + -1, 1209, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1775, 1776, -1, -1, -1, 1780, 1781, -1, -1, + -1, 1785, 1786, 1787, 1788, 8, 1790, 1791, 11, -1, + -1, -1, 15, 16, -1, -1, 19, 20, 21, -1, + -1, -1, 1297, 1807, -1, -1, -1, 2328, -1, 294, + 2203, 1815, -1, 1817, 1818, 1819, 1820, 1821, -1, 449, + -1, -1, -1, -1, 454, -1, -1, 535, 313, -1, + -1, -1, 540, 2450, 1838, 543, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1851, -1, 1297, + -1, 3408, -1, -1, -1, -1, -1, -1, 859, -1, + 1902, 1903, 1904, 1905, 1906, 1907, -1, -1, 1910, 1911, + 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, -1, -1, + -1, -1, -1, -1, -1, 370, -1, -1, -1, 2506, + -1, 26, 377, -1, -1, -1, -1, 32, 1902, 1903, + 1904, 1905, 1906, 1907, -1, 40, 1910, 1911, 1912, 1913, + 1914, 1915, 1916, 1917, 1918, 1919, -1, -1, -1, 1518, + -1, -1, -1, -1, -1, 60, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 420, 1940, 422, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1952, -1, + -1, -1, -1, -1, 439, -1, -1, -1, 1962, -1, + 445, -1, -1, 448, 1968, 3408, -1, -1, -1, -1, + 1974, 106, -1, -1, -1, 1979, -1, -1, -1, -1, + -1, -1, 2318, -1, 1988, 1989, -1, -1, -1, -1, + -1, -1, 2609, -1, -1, -1, -1, -1, 221, 1000, + -1, -1, 137, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1611, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1023, 1518, -1, -1, 1902, 1903, 1904, 1905, + 1906, 1907, -1, -1, 1910, 1911, 1912, 1913, 1914, 1915, + 1916, 1917, 1918, 1919, -1, -1, -1, 2089, 2090, 2570, + 2571, -1, -1, 2057, -1, -1, -1, 2061, -1, -1, + -1, -1, 2066, -1, -1, -1, 201, -1, 291, -1, + 1518, -1, -1, -1, -1, -1, -1, 2598, -1, -1, + -1, -1, -1, 791, -1, 2089, 2090, 2704, 1089, -1, + -1, -1, 2613, 2614, 2615, 2616, 2617, 2618, 2619, 2620, + 2621, 2622, 2106, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 2450, 250, 1611, 2510, 2511, -1, + -1, -1, -1, -1, -1, 260, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 2139, -1, 272, -1, -1, + -1, -1, -1, -1, -1, -1, 1745, 2151, -1, -1, + -1, -1, 2156, -1, 1155, 1156, 2160, -1, 293, -1, + -1, 2203, -1, 1611, 2781, -1, -1, -1, -1, 304, + 2506, -1, -1, 8, -1, -1, 11, 885, -1, -1, + 15, 16, -1, -1, 19, 20, 21, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 2200, -1, -1, 2203, + -1, -1, 2206, -1, -1, -1, -1, -1, -1, 917, + -1, -1, -1, 2089, 2090, 350, -1, -1, 2222, 354, + -1, 356, -1, -1, -1, 933, 934, 935, 936, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 98, -1, -1, -1, -1, 381, -1, -1, -1, + 1745, 386, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 400, -1, -1, -1, 126, + 127, 2888, -1, 2609, -1, -1, -1, 985, 501, 502, + 503, -1, 505, 506, 507, 508, 509, 510, -1, 2293, + 1889, -1, -1, -1, -1, -1, 2300, 1745, -1, -1, + -1, -1, 1901, -1, -1, 2922, -1, 2311, 2701, -1, + 2314, 2315, 2316, 2317, 171, -1, -1, -1, -1, -1, + -1, -1, 457, -1, 2328, -1, 2330, 1328, 1329, 2333, + 1331, -1, 1931, 2726, 2338, -1, -1, -1, 2859, 1938, + 2344, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 2362, 2363, + -1, 2365, -1, 198, -1, -1, -1, -1, 2704, -1, + -1, -1, -1, -1, -1, -1, -1, 1976, -1, -1, + -1, 1980, -1, -1, 3001, -1, 221, 1986, -1, -1, + 2394, -1, -1, -1, 1889, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1901, -1, -1, 2008, + 2414, -1, -1, -1, -1, -1, -1, -1, 2422, 2423, + 2424, -1, -1, -1, -1, -1, -1, 3044, 2432, -1, + 2434, 1432, 2436, -1, -1, -1, 1931, -1, 2442, -1, + -1, 1889, -1, 1938, -1, 2781, -1, -1, -1, -1, + -1, -1, -1, 1901, -1, -1, 291, 314, 315, 316, + -1, -1, 1463, -1, 1465, -1, -1, 2860, 2510, 2511, + -1, 2475, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1976, -1, 1931, -1, 1980, -1, 1195, -1, -1, + 1938, 1986, -1, -1, -1, -1, -1, -1, -1, -1, + 1208, -1, -1, -1, -1, -1, 2510, 2511, -1, -1, + -1, -1, -1, 2008, -1, -1, -1, -1, -1, -1, + -1, 1229, 379, -1, -1, -1, -1, -1, 1976, 3146, + -1, -1, 1980, 390, -1, 2539, -1, -1, 1986, -1, + -1, 2545, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 2888, -1, -1, 412, -1, 2561, -1, 416, + 2008, 2565, -1, -1, -1, 2569, 2570, 2571, -1, -1, + -1, 2575, 2576, 2577, -1, 2579, -1, -1, -1, 436, + -1, -1, -1, -1, 1292, -1, 2922, -1, -1, -1, + -1, -1, 449, 1301, 2598, -1, 2600, -1, -1, -1, + -1, -1, -1, 460, -1, 3126, -1, 3000, -1, 2613, + 2614, 2615, 2616, 2617, 2618, 2619, 2620, 2621, 2622, 476, + -1, -1, -1, -1, -1, -1, 3147, 3148, -1, -1, + -1, -1, -1, 8, 2510, 2511, 11, -1, -1, -1, + 15, 16, 2646, 500, 19, 20, 21, -1, 2652, -1, + -1, -1, 3173, -1, -1, -1, -1, 514, -1, 2701, + 2664, 36, -1, -1, -1, 3001, 501, 502, 503, -1, + 505, 506, 507, 508, 509, 510, 2680, -1, -1, -1, + -1, 835, 836, -1, 2726, -1, 2690, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 2701, -1, -1, + -1, -1, -1, 2707, -1, -1, -1, -1, 3044, -1, + 2714, 2715, 2716, 2717, -1, -1, -1, -1, -1, 2318, + -1, -1, 2726, 1724, -1, 2729, -1, -1, 2770, 2733, + 2734, -1, 1440, -1, 8, -1, -1, 11, 2742, 1740, + -1, 15, 16, -1, -1, 19, 20, 21, 902, 1750, + -1, 1752, 906, 907, 1755, -1, -1, -1, -1, -1, + 1761, -1, 1763, -1, -1, 2769, -1, -1, -1, -1, + -1, -1, 46, -1, -1, 1776, -1, -1, -1, 53, + 1781, -1, -1, -1, 1785, 1786, 1787, 1788, -1, 1790, + 1791, 3408, -1, -1, -1, 2799, -1, 2801, -1, -1, + -1, -1, -1, -1, -1, 959, 80, -1, -1, -1, + 3146, 2815, -1, -1, -1, 2819, -1, 3210, 2860, -1, + -1, 2825, -1, 2318, 978, 2701, -1, -1, -1, -1, + 984, -1, -1, 987, -1, 2839, 990, 991, 992, 993, + -1, 2845, -1, -1, -1, -1, 221, -1, -1, -1, + -1, 2450, -1, -1, 2858, 2859, 2860, -1, -1, -1, + -1, -1, 2866, -1, -1, -1, -1, -1, -1, -1, + 2318, -1, -1, 8, -1, -1, 11, 1031, 1032, 2883, + 15, 16, -1, 3404, 19, 20, 21, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1052, -1, + -1, -1, 176, -1, -1, -1, -1, 2506, -1, -1, + -1, -1, -1, -1, -1, -1, 291, 1071, -1, 193, + -1, -1, -1, -1, 198, -1, -1, -1, 1082, 1083, + 1084, -1, 1086, 1087, -1, -1, -1, -1, -1, 1940, + -1, -1, -1, -1, -1, -1, -1, 221, 222, -1, + -1, -1, -1, -1, -1, 2450, -1, 2961, 3000, -1, + -1, 2965, 236, -1, 1672, 1119, 1674, -1, -1, -1, + -1, -1, -1, 1974, -1, 2979, 1684, -1, 1979, -1, + -1, -1, 1136, 1137, 2860, -1, -1, -1, -1, 2993, + -1, -1, -1, -1, -1, -1, 3000, -1, -1, -1, + 274, -1, 2450, 277, -1, -1, -1, -1, -1, -1, + 2609, 2506, -1, -1, 1722, -1, 1170, 291, -1, -1, + 1174, 1175, 3026, -1, -1, -1, -1, -1, 3032, -1, + -1, 1185, 1186, -1, -1, 3039, 8, -1, -1, 11, + -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, + -1, -1, -1, -1, -1, -1, 2057, -1, 2506, -1, + -1, -1, -1, 198, 36, 2066, -1, -1, -1, 3073, + -1, -1, 3408, -1, 46, -1, -1, -1, -1, -1, + -1, 53, 8, -1, -1, 11, 221, -1, 1242, 15, + 16, 3095, -1, 19, 20, 21, 3100, 1251, -1, -1, + -1, -1, -1, -1, -1, 2704, -1, -1, 80, 1817, + 1818, 1819, 1820, 1821, 2609, -1, -1, 391, -1, -1, + -1, 1275, 3126, -1, 3000, -1, 501, 502, 503, -1, + 505, 506, 507, 508, 509, 510, -1, -1, -1, -1, + -1, -1, -1, 3147, 3148, -1, -1, -1, -1, -1, + 2151, -1, -1, -1, -1, -1, 291, -1, -1, -1, + -1, 2609, 3166, 8, 3168, -1, 11, -1, 3210, 3173, + 15, 16, -1, -1, 19, 20, 21, -1, -1, -1, + -1, -1, 2781, 3187, -1, -1, 3190, -1, -1, -1, + -1, 36, -1, -1, -1, -1, -1, -1, -1, 2200, + -1, -1, -1, -1, 176, 2206, 3210, -1, 1362, 2704, + 3214, 3215, -1, 3217, -1, -1, -1, -1, -1, -1, + -1, 193, -1, -1, 498, -1, 198, 501, 502, 503, + -1, 505, 506, 507, 508, 509, 510, -1, 3242, -1, + -1, -1, -1, -1, 1952, 3249, -1, -1, -1, 221, + 222, -1, -1, -1, -1, -1, 2704, -1, -1, -1, + -1, -1, -1, -1, 236, -1, -1, -1, 1422, -1, + 1424, 1425, -1, -1, -1, -1, 3280, -1, -1, -1, + -1, -1, -1, 1437, 1438, -1, 2781, -1, -1, 2888, + -1, -1, -1, -1, -1, 221, -1, -1, -1, -1, + 1454, -1, 274, -1, -1, 277, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 3319, -1, -1, -1, 291, + -1, -1, 294, 2922, -1, -1, -1, 2328, -1, -1, + -1, -1, -1, 2781, -1, -1, -1, 3341, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2288, -1, -1, -1, -1, - -1, 2294, -1, -1, -1, -1, -1, -1, -1, -1, - 145, -1, 2697, 2306, 2307, 2308, 2309, -1, 291, -1, - -1, -1, -1, -1, -1, -1, -1, 2320, 2697, 2322, - -1, -1, 2325, -1, -1, -1, 2329, -1, -1, 2774, - 2333, 176, -1, -1, -1, -1, 2339, -1, -1, -1, - -1, -1, 2089, -1, -1, -1, 1327, 1328, 193, 1330, - -1, -1, -1, 198, 2357, 2358, -1, 2360, 2602, 3140, - 2107, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 2123, -1, -1, 2774, - -1, -1, -1, -1, -1, 8, 2389, 2134, 11, -1, - -1, 236, 15, 16, -1, 2774, 19, 20, 21, -1, - -1, -1, -1, -1, 2151, -1, 2409, -1, 391, -1, - -1, -1, -1, -1, 2417, 2418, 2419, -1, -1, -1, - -1, -1, -1, 2426, -1, 2428, 2429, -1, -1, -1, - -1, -1, 2435, -1, -1, -1, 2881, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 291, -1, -1, -1, - 1431, -1, -1, 2697, -1, 501, 502, 503, -1, 505, - 506, 507, 508, 509, 510, 2468, -1, -1, -1, -1, - 2915, -1, -1, -1, -1, -1, -1, -1, -1, 1460, - -1, 1462, -1, -1, -1, -1, 2881, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2503, 2504, 2881, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 498, -1, -1, -1, -1, - 2915, -1, 505, 506, 507, 508, 509, 510, -1, 2532, - 2774, -1, -1, -1, -1, 2538, 2915, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 391, -1, -1, 2994, - -1, 2554, -1, -1, -1, 2558, -1, 2304, -1, 2562, - 2563, 2564, -1, -1, -1, 2568, 2569, 2570, -1, 2572, - -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, - 988, -1, -1, -1, -1, -1, -1, -1, 2591, -1, - 2593, -1, -1, 3038, -1, -1, -1, -1, 221, 2994, - -1, -1, -1, 2606, 2607, 2608, 2609, 2610, 2611, 2612, - 2613, 2614, 2615, -1, -1, 2994, -1, -1, -1, -1, - -1, -1, -1, -1, 3405, -1, -1, -1, -1, -1, - -1, -1, -1, 8, -1, 2638, 11, 2881, -1, -1, - 15, 16, 2645, 3038, 19, 20, 21, -1, -1, -1, - -1, -1, 2655, 498, -1, -1, -1, -1, -1, 3038, - 505, 506, 507, 508, 509, 510, -1, -1, 291, -1, - 2673, 2915, -1, 100, 988, -1, -1, -1, -1, -1, - 2683, 98, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 2694, -1, -1, -1, 3140, -1, 2700, -1, -1, - -1, -1, -1, -1, 2707, 2708, 2709, 2710, -1, 126, - 127, -1, -1, -1, -1, -1, 2719, -1, -1, 2722, - 147, -1, -1, 2726, 2727, -1, -1, -1, -1, 2476, - -1, -1, 2735, -1, 161, -1, -1, -1, -1, 166, - -1, 1722, -1, -1, 171, 3140, -1, -1, -1, -1, - 2994, -1, -1, 180, 171, -1, 1737, -1, 185, 2762, - -1, 3140, 2509, -1, -1, -1, 1747, 1175, 1749, -1, - -1, 1752, -1, -1, -1, -1, 1184, 1758, -1, 1760, - -1, 2528, -1, -1, -1, -1, -1, 2534, -1, 2792, - 217, 2794, 1773, -1, 3038, -1, -1, 1778, -1, -1, - -1, 1782, 1783, 1784, 1785, 2808, 1787, 1788, -1, 2812, - 237, -1, -1, 2560, -1, 2818, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 2832, - -1, -1, -1, -1, -1, 2838, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 221, -1, 2851, 2852, - 2853, -1, -1, -1, -1, -1, 2859, -1, -1, 286, - -1, -1, 289, -1, -1, -1, -1, -1, 295, -1, - 1184, -1, -1, 2876, -1, -1, -1, -1, 501, 502, - 503, -1, 505, 506, 507, 508, 509, 510, -1, -1, - -1, -1, 2639, -1, -1, -1, 3140, 314, 315, 316, - -1, -1, -1, -1, -1, -1, -1, -1, 335, -1, - -1, -1, -1, -1, -1, -1, 291, -1, -1, 2666, - -1, -1, 2669, -1, -1, -1, -1, -1, -1, -1, - -1, 358, -1, -1, -1, -1, -1, -1, -1, 8, - -1, -1, 11, -1, -1, -1, 15, 16, -1, -1, - -1, 2954, -1, -1, 2957, -1, 1937, -1, -1, -1, - 3405, -1, 379, -1, -1, -1, -1, 2970, -1, -1, - -1, -1, 2719, 390, -1, -1, -1, 46, -1, -1, - -1, -1, -1, 2986, 53, -1, -1, -1, 1969, 416, - 2993, -1, -1, 1974, -1, 412, -1, -1, -1, 416, - 1408, 1409, -1, -1, -1, -1, 1414, -1, -1, 0, - 3405, 80, -1, -1, -1, -1, 3019, 444, -1, 436, - -1, -1, 3025, -1, -1, -1, 3405, 454, -1, -1, - 3033, -1, 449, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 460, -1, -1, 473, 2794, 475, 476, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 476, - -1, 2808, -1, -1, 3067, -1, -1, -1, -1, -1, - -1, 2052, -1, -1, -1, -1, 145, -1, -1, -1, - 2061, -1, -1, 500, -1, 512, 3089, -1, 515, 516, - 517, 3094, -1, -1, 1408, 1409, -1, 514, -1, -1, - 1414, -1, -1, -1, -1, -1, -1, 176, -1, 100, - -1, -1, -1, -1, -1, -1, -1, 3120, -1, -1, - -1, 835, 836, -1, 193, -1, 501, 502, 503, 198, - 505, 506, 507, 508, 509, 510, -1, -1, 3141, 3142, + -1, -1, -1, -1, 3368, 291, 501, 502, 503, -1, + 505, 506, 507, 508, 509, 510, 221, 3381, 3382, -1, + 3384, 3385, -1, -1, -1, -1, -1, -1, -1, 3393, + -1, -1, -1, 2888, -1, -1, -1, -1, -1, -1, + 3404, -1, 3001, -1, -1, 1559, -1, -1, -1, -1, + -1, -1, -1, 1567, -1, -1, -1, -1, -1, 391, + -1, -1, 3426, -1, -1, -1, -1, 2922, -1, 3433, + -1, 2432, -1, -1, -1, 2436, -1, -1, -1, -1, + 2888, 2442, -1, -1, -1, 3044, 291, -1, -1, -1, + -1, -1, 1606, -1, -1, -1, -1, -1, 1612, 1613, + 1614, 1615, 1616, 1617, 1618, 1619, 3470, -1, -1, -1, + 1624, 1625, -1, -1, 2922, 1629, -1, -1, -1, 1633, + -1, 3485, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, + 1644, -1, -1, 1647, -1, -1, -1, -1, -1, -1, + 1654, 8, 1656, -1, 11, -1, 3001, -1, 15, 16, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 147, 3160, -1, 3162, - -1, 3405, -1, 3166, -1, 2146, -1, 236, -1, -1, - 161, -1, -1, -1, -1, 166, -1, -1, 3181, -1, - 171, 3184, -1, -1, -1, -1, -1, -1, 902, 180, - -1, -1, 906, 907, 185, -1, -1, -1, -1, -1, - -1, 3204, -1, -1, -1, 3208, 3209, -1, -1, 3212, - -1, -1, -1, -1, 2195, -1, -1, -1, -1, -1, - 2201, -1, 291, -1, 2971, -1, 217, -1, -1, -1, - -1, -1, -1, -1, 3237, -1, -1, -1, -1, -1, - -1, 3244, -1, -1, -1, 959, 237, -1, -1, -1, + -1, 1675, -1, -1, -1, -1, 498, -1, -1, 501, + 502, 503, -1, 505, 506, 507, 508, 509, 510, 46, + -1, -1, -1, -1, -1, -1, 53, 3146, -1, 3044, + -1, -1, 524, 3001, 1708, 1709, -1, -1, -1, -1, + -1, -1, -1, -1, 2565, -1, -1, -1, 2569, 2570, + 2571, -1, -1, 80, -1, 501, 502, 503, -1, 505, + 506, 507, 508, 509, 510, -1, -1, -1, -1, -1, + -1, -1, 2300, -1, -1, -1, 3044, 2598, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 2315, 2316, 2317, + -1, -1, 2613, 2614, 2615, 2616, 2617, 2618, 2619, 2620, + 2621, 2622, 2330, -1, -1, 2333, -1, -1, -1, -1, + 2338, -1, -1, -1, -1, -1, -1, -1, 145, -1, + -1, -1, 1796, -1, -1, -1, 1800, -1, -1, 1803, + 1804, 3146, -1, -1, -1, -1, 501, 502, 503, -1, + 505, 506, 507, 508, 509, 510, -1, -1, -1, 176, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 3009, -1, 978, -1, -1, -1, -1, -1, - 984, -1, 3275, 987, -1, -1, 990, 991, 992, 993, - -1, -1, -1, -1, -1, -1, -1, 1695, -1, -1, - -1, -1, -1, -1, -1, 286, -1, -1, 289, -1, - -1, -1, -1, -1, 295, -1, -1, -1, -1, -1, - -1, 3314, -1, -1, -1, -1, -1, 1031, 1032, -1, - -1, -1, 391, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 3337, 1649, -1, -1, 1052, 2320, - -1, -1, -1, -1, 335, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1071, -1, -1, - -1, 3364, -1, -1, -1, -1, -1, 358, 1082, 1083, - 1084, -1, 1086, 1087, 3377, 3378, -1, 3380, 3381, -1, - -1, 1695, -1, -1, -1, -1, 3389, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 3401, -1, - -1, -1, -1, -1, 1118, -1, -1, -1, -1, 3156, - 3157, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3423, 1135, 1136, -1, -1, 416, -1, 3430, -1, 498, - -1, -1, -1, -1, -1, -1, 505, 506, 507, 508, - 509, 510, -1, -1, -1, 2426, -1, -1, 2429, -1, - -1, -1, -1, 444, 2435, -1, 1170, -1, -1, -1, - 1174, 1175, -1, 454, -1, 3468, -1, -1, -1, -1, - -1, 1185, 1186, -1, -1, -1, -1, -1, -1, -1, - 3483, -1, 473, -1, 475, 476, -1, 3234, -1, 3236, - -1, 1899, 1900, 1901, 1902, 1903, 1904, -1, -1, 1907, - 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, -1, + -1, -1, -1, -1, -1, -1, 193, -1, -1, -1, + 1844, 198, -1, -1, -1, -1, -1, -1, 3146, -1, + -1, -1, -1, -1, -1, -1, 2707, -1, -1, 1863, + 1864, -1, -1, -1, 2422, 2423, 2424, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 236, + -1, -1, 2733, -1, -1, -1, -1, -1, -1, 1893, + 1894, -1, 1896, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 512, -1, -1, 515, 516, 517, 1241, -1, 3276, - -1, -1, -1, -1, -1, -1, 1250, -1, -1, -1, - -1, -1, -1, -1, -1, 3292, -1, -1, -1, 3296, + 8, -1, -1, 11, -1, 0, -1, 15, 16, -1, + -1, 1925, 1926, -1, -1, 1929, -1, -1, -1, -1, + -1, -1, -1, -1, 291, -1, -1, 22, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 32, 46, 34, + 35, -1, -1, -1, 1958, 53, -1, -1, -1, 3408, + 1964, -1, 47, -1, -1, -1, -1, 52, -1, -1, + -1, -1, -1, -1, -1, -1, 61, -1, 1982, -1, + 1984, -1, 80, -1, -1, -1, -1, -1, -1, -1, + 75, -1, -1, -1, -1, -1, -1, -1, -1, 84, + -1, 86, -1, 2561, -1, -1, -1, -1, 2859, -1, + -1, -1, -1, 98, -1, 100, 2020, -1, -1, -1, + -1, -1, 26, -1, -1, -1, 111, -1, 32, -1, + -1, -1, -1, -1, 391, 37, 40, -1, -1, -1, + 42, 126, 127, 128, -1, -1, -1, 145, -1, -1, + -1, -1, 137, -1, -1, 2059, 60, -1, 143, -1, + 2064, 2065, -1, 3408, -1, -1, 151, -1, 153, 154, + -1, -1, -1, -1, -1, -1, -1, -1, 176, -1, + -1, -1, 167, -1, -1, -1, 171, -1, -1, -1, + -1, -1, -1, -1, 2652, 193, -1, -1, -1, 101, + 198, -1, 106, -1, 2108, -1, -1, 2111, -1, 2113, + 3408, -1, 197, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 2129, -1, -1, 213, -1, + -1, -1, -1, 137, -1, -1, -1, -1, 236, -1, + -1, 498, -1, -1, -1, -1, -1, -1, 505, 506, + 507, 508, 509, 510, 239, -1, 2714, 2715, 2716, 2717, + -1, -1, -1, -1, -1, 2169, -1, -1, -1, -1, + 172, -1, -1, -1, -1, -1, -1, -1, 180, -1, + -1, 3032, 2186, 2187, -1, -1, -1, -1, 3039, -1, + -1, -1, -1, 291, -1, -1, -1, 201, -1, -1, + -1, 2205, -1, -1, -1, 8, 208, -1, 11, -1, + 2214, -1, 15, 16, 17, 18, 19, 20, 21, -1, + -1, -1, 224, -1, -1, -1, -1, -1, -1, 314, + 315, 316, 234, 36, -1, -1, -1, 322, 988, -1, + 325, -1, -1, 46, 3095, -1, 250, -1, -1, 3100, + 53, -1, -1, -1, -1, -1, 260, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 268, 2271, 272, 354, + -1, -1, -1, 2277, -1, 3126, -1, 80, 363, -1, + -1, -1, -1, -1, -1, -1, -1, 289, -1, 293, + -1, -1, -1, 391, 379, -1, 3147, 3148, -1, -1, + 304, 386, -1, -1, -1, 390, -1, -1, 2866, -1, + -1, -1, 314, -1, -1, 400, -1, -1, -1, 321, + -1, -1, 3173, 37, -1, -1, -1, 412, 42, -1, + -1, 416, 2336, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 350, -1, -1, -1, + 354, 436, 356, -1, -1, -1, -1, 1107, -1, 361, + -1, -1, -1, 3214, 449, -1, -1, 452, -1, -1, + 455, -1, -1, 176, -1, 460, -1, 381, 380, -1, + -1, -1, 386, -1, -1, -1, -1, 101, -1, -1, + 193, 476, -1, -1, -1, 198, 400, -1, -1, -1, + 498, 1151, -1, -1, -1, -1, -1, 505, 506, 507, + 508, 509, 510, -1, -1, 500, -1, -1, 221, 222, + -1, -1, -1, 3, -1, -1, -1, -1, 8, 514, + -1, 11, 517, 236, 1184, 15, 16, 17, 18, 19, + 20, 21, -1, -1, -1, -1, -1, 449, -1, -1, + -1, -1, 454, 457, -1, -1, 36, -1, 172, -1, + 40, -1, 2466, -1, -1, -1, 46, -1, 2472, 2473, + -1, 274, -1, 53, 277, -1, -1, -1, -1, 2483, + -1, -1, -1, -1, -1, -1, 1236, -1, 291, -1, + 2494, 294, -1, 2497, 208, 2499, -1, -1, -1, -1, + 80, -1, -1, 2507, -1, -1, -1, -1, -1, -1, + 224, 2515, 2516, -1, -1, -1, -1, -1, 2522, -1, + 234, -1, -1, -1, -1, -1, -1, -1, 1278, -1, + -1, -1, -1, 2537, -1, 1285, -1, -1, -1, -1, + -1, -1, -1, 2547, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3404, 268, -1, -1, -1, -1, -1, + -1, -1, -1, 2567, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 289, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1335, -1, -1, 391, -1, + -1, -1, -1, -1, -1, -1, 176, -1, -1, -1, + 314, -1, -1, -1, -1, -1, -1, 321, 3166, -1, + 1360, -1, -1, 193, -1, -1, -1, -1, 198, -1, + 2624, -1, 2626, -1, -1, -1, -1, -1, -1, 3187, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1274, -1, 68, 69, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 2558, -1, -1, - -1, 2562, 2563, 2564, -1, 1899, 1900, 1901, 1902, 1903, - 1904, -1, -1, 1907, 1908, 1909, 1910, 1911, 1912, 1913, - 1914, 1915, 1916, 109, 110, -1, -1, 113, 114, -1, - 2591, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2606, 2607, 2608, 2609, 2610, - 2611, 2612, 2613, 2614, 2615, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1361, -1, -1, - -1, -1, -1, -1, -1, -1, 24, -1, -1, -1, + -1, 221, 222, -1, -1, -1, -1, 361, -1, -1, + -1, -1, -1, -1, -1, 1405, 236, 1407, -1, 1409, + 1410, -1, 1412, -1, -1, 1415, 380, -1, 1418, -1, + -1, 1421, -1, -1, -1, -1, 1426, -1, -1, 1429, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3422, 2084, 2085, -1, -1, - -1, -1, 188, 189, -1, -1, -1, -1, -1, -1, + -1, 3249, -1, -1, 274, 498, -1, 277, 501, 502, + 503, -1, 505, 506, 507, 508, 509, 510, -1, -1, + -1, 291, -1, -1, 294, 518, -1, 2721, 2722, -1, + -1, 1471, 3280, -1, -1, -1, -1, -1, -1, 24, + -1, -1, -1, -1, -1, 449, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 3449, -1, -1, -1, -1, 1421, -1, 1423, - 1424, -1, -1, 81, -1, -1, -1, -1, -1, 2700, - -1, -1, 1436, 1437, -1, -1, -1, -1, -1, 97, - -1, -1, -1, -1, -1, -1, -1, -1, 1452, -1, - -1, -1, -1, -1, -1, 2726, 252, 253, 254, 255, - 256, 257, 258, 259, -1, -1, 262, 263, -1, -1, + -1, -1, 2756, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 2770, -1, -1, -1, + -1, 2775, 2776, -1, -1, -1, 2780, -1, -1, -1, + -1, 2785, -1, -1, 2788, 2789, 81, -1, -1, 2793, + 2794, -1, -1, 2797, -1, -1, -1, -1, -1, -1, + -1, -1, 97, -1, 2808, 1555, -1, -1, -1, -1, + -1, 391, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1571, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1581, 1582, 1583, -1, -1, -1, 1587, -1, -1, + -1, 1591, -1, -1, -1, 3, -1, 5, 2852, -1, + -1, 146, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 156, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 168, -1, 2879, -1, -1, 173, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2084, 2085, -1, -1, -1, -1, -1, -1, 146, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 156, -1, - 2198, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 168, -1, -1, -1, -1, 173, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1653, -1, -1, -1, 202, -1, -1, + 68, 69, -1, -1, -1, -1, -1, -1, 498, -1, + -1, 501, 502, 503, -1, 505, 506, 507, 508, 509, + 510, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1691, -1, -1, -1, -1, -1, -1, -1, -1, + 245, 109, 110, -1, 249, 113, 114, 1707, -1, -1, + -1, 8, 1712, -1, 11, 2969, -1, -1, 15, 16, + 17, 18, 19, 20, 21, -1, -1, -1, -1, 1729, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 36, + -1, -1, -1, 40, -1, -1, -1, -1, -1, 46, + -1, -1, -1, -1, -1, -1, 53, -1, 8, -1, + -1, 11, 3016, -1, -1, 15, 16, 17, 18, 19, + 20, 21, -1, -1, 319, -1, -1, -1, -1, -1, + 188, 189, -1, 80, -1, -1, 36, -1, -1, 334, + -1, -1, -1, -1, -1, 3049, 46, -1, -1, -1, + -1, -1, -1, 53, -1, -1, 3060, 3061, -1, -1, + 3064, -1, 3066, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 367, -1, -1, 370, -1, -1, -1, -1, + 80, -1, -1, -1, -1, -1, 381, 3091, -1, 384, + -1, -1, -1, -1, 252, 253, 254, 255, 256, 257, + 258, 259, -1, -1, 262, 263, -1, 402, -1, -1, + -1, 3115, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 416, -1, -1, -1, -1, -1, -1, 423, 176, + -1, -1, -1, -1, -1, -1, -1, -1, 433, -1, + -1, 1891, -1, -1, 439, -1, 193, -1, -1, 1899, + 1900, 198, 1902, 1903, 1904, 1905, 1906, 1907, -1, -1, + 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, + 1920, 466, -1, -1, 221, 222, 176, -1, -1, -1, + -1, -1, 3186, -1, -1, -1, -1, -1, -1, 236, + -1, -1, -1, 193, -1, -1, -1, -1, 198, -1, + 3204, -1, -1, -1, 3208, -1, -1, -1, 3212, -1, + -1, -1, -1, -1, -1, -1, -1, 375, 376, 3223, + -1, 221, 222, -1, 3228, -1, 3230, 274, -1, -1, + 277, -1, -1, -1, 3238, -1, 236, -1, -1, -1, + -1, -1, -1, -1, 291, -1, -1, 294, -1, -1, + -1, -1, 3256, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 202, -1, -1, -1, -1, -1, - -1, -1, 1556, -1, -1, -1, -1, -1, -1, -1, - 1564, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 375, - 376, 2852, -1, -1, -1, -1, -1, 245, -1, -1, - -1, 249, -1, -1, 2198, -1, -1, -1, -1, 1603, - -1, -1, -1, -1, -1, 1609, 1610, 1611, 1612, 1613, - 1614, 1615, 1616, -1, -1, -1, -1, 1621, 1622, -1, - -1, -1, 1626, -1, -1, -1, 1630, -1, -1, 1633, - 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, -1, -1, - 1644, -1, -1, -1, -1, 8, -1, 1651, 11, 1653, - -1, -1, 15, 16, 17, 18, 19, 20, 21, -1, - -1, 319, -1, -1, -1, -1, -1, -1, 1672, -1, - -1, -1, -1, 36, 470, 471, 334, -1, -1, -1, - -1, -1, -1, 46, -1, -1, -1, -1, -1, -1, - 53, -1, -1, -1, -1, -1, -1, -1, 494, 495, - -1, -1, 1706, 1707, -1, -1, -1, -1, -1, 367, - -1, -1, 370, -1, -1, -1, -1, 80, 514, -1, - -1, -1, 8, 381, -1, 11, 384, -1, -1, 15, - 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, - -1, -1, -1, -1, 402, -1, -1, -1, -1, -1, - 36, -1, -1, -1, 3025, -1, -1, -1, 416, -1, - 46, -1, 3033, 988, -1, 423, -1, 53, -1, -1, - -1, -1, -1, -1, -1, 433, -1, -1, -1, -1, - -1, 439, -1, -1, -1, -1, -1, -1, -1, 1793, - -1, -1, -1, 1797, 80, -1, 1800, 1801, -1, -1, - -1, -1, -1, -1, -1, 2503, 2504, -1, 466, -1, - -1, -1, -1, 176, -1, -1, -1, -1, 3089, -1, - -1, -1, -1, 3094, -1, -1, -1, -1, -1, -1, - 193, -1, -1, -1, 1838, 198, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 3120, - -1, -1, -1, -1, -1, -1, 1860, 1861, 221, 222, + -1, -1, -1, 2023, 274, -1, 2026, 277, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3141, 3142, -1, 236, -1, -1, -1, -1, -1, -1, - -1, -1, 1107, -1, -1, -1, 1890, 1891, -1, 1893, - 176, -1, -1, -1, -1, 3166, -1, -1, -1, 2503, - 2504, -1, -1, -1, -1, -1, -1, 193, -1, -1, - -1, 274, 198, -1, 277, -1, -1, -1, 1922, 1923, - 0, -1, 1926, -1, -1, 1150, -1, -1, 291, -1, - -1, 294, -1, -1, -1, 221, 222, 3208, -1, -1, - -1, -1, 22, -1, -1, -1, -1, -1, -1, -1, - 236, 1955, 32, -1, 34, 35, 1960, -1, -1, 1184, - -1, -1, -1, -1, -1, -1, -1, 47, -1, -1, - -1, -1, 52, 1977, -1, 1979, -1, -1, -1, -1, - -1, 61, -1, -1, -1, -1, -1, -1, 274, -1, - -1, 277, -1, -1, -1, 75, 2694, -1, -1, -1, - -1, -1, -1, -1, 84, 291, 86, -1, 294, -1, - 1235, 2015, -1, -1, -1, -1, -1, -1, 98, -1, - 100, 2719, -1, -1, -1, -1, -1, -1, 391, -1, - -1, 111, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 126, 127, 128, -1, - 2054, -1, -1, -1, 1279, 2059, 2060, 137, -1, 1284, - -1, -1, -1, 143, -1, 2763, -1, -1, -1, -1, - -1, 151, -1, 153, 154, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 167, -1, -1, - 2694, 171, -1, -1, -1, -1, -1, -1, -1, 2103, - -1, -1, 2106, -1, 2108, 391, -1, -1, -1, 1334, - -1, -1, -1, -1, -1, 2719, -1, 197, -1, -1, - 2124, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3401, -1, -1, 213, 1359, 498, -1, -1, 501, 502, - 503, -1, 505, 506, 507, 508, 509, 510, -1, -1, - -1, -1, -1, -1, -1, 2853, -1, -1, -1, 239, - 2164, 524, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 2181, 2182, 1404, - -1, 1406, -1, 1408, 1409, -1, 1411, -1, -1, 1414, - -1, -1, 1417, -1, -1, 1420, 2200, -1, -1, -1, - 1425, -1, -1, 1428, -1, 2209, -1, -1, -1, -1, - -1, -1, 498, -1, -1, 501, 502, 503, -1, 505, - 506, 507, 508, 509, 510, -1, -1, -1, -1, -1, - -1, -1, 518, -1, 314, 315, 316, -1, -1, -1, - -1, -1, 322, 1468, -1, 325, -1, -1, -1, 2853, + -1, 291, -1, -1, 294, -1, -1, -1, -1, -1, + -1, 3305, -1, -1, -1, -1, -1, 8, -1, -1, + 11, 3315, 470, 471, 15, 16, 17, 18, 19, 20, + 21, -1, 2072, 3327, -1, -1, 2076, 2077, 2078, 2079, + 2080, 2081, 2082, 2083, -1, 36, 494, 495, -1, 2089, + 2090, -1, 2092, 2093, 391, 46, -1, -1, -1, -1, + -1, -1, 53, -1, 2104, 3359, -1, 2107, -1, -1, + -1, -1, -1, -1, -1, 2115, 2116, 2117, 2118, 2119, + 2120, 2121, 2122, 2123, 2124, -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 2266, -1, -1, -1, -1, -1, 2272, -1, - -1, -1, -1, -1, 354, -1, -1, -1, -1, -1, - -1, -1, -1, 363, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2993, -1, -1, -1, 379, - -1, -1, -1, -1, -1, -1, 386, -1, -1, -1, - 390, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 400, -1, -1, -1, 2328, -1, -1, 1552, -1, -1, - -1, -1, 412, -1, -1, -1, 416, -1, -1, -1, - -1, -1, -1, 1568, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1578, 1579, 1580, 436, -1, -1, 1584, - -1, -1, -1, 1588, -1, -1, -1, -1, -1, 449, - -1, -1, 452, -1, -1, 455, -1, -1, -1, -1, - 460, -1, -1, -1, -1, -1, -1, -1, -1, 2993, - -1, -1, -1, -1, -1, -1, 476, -1, -1, 68, - 69, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 391, -1, -1, 8, -1, -1, 11, -1, -1, + 2150, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 500, -1, -1, -1, -1, 1650, -1, -1, -1, -1, - -1, -1, -1, -1, 514, -1, -1, 517, -1, -1, - 109, 110, -1, -1, 113, 114, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2459, -1, -1, -1, -1, - -1, 2465, 2466, -1, 1689, -1, -1, -1, -1, -1, - -1, -1, 2476, -1, -1, -1, -1, -1, -1, -1, - 1705, -1, -1, 2487, -1, 1710, 2490, -1, 2492, -1, - -1, -1, -1, -1, -1, -1, 2500, -1, -1, -1, - -1, -1, 1727, -1, 2508, 2509, 3204, -1, -1, -1, - -1, 2515, -1, -1, -1, -1, -1, -1, -1, 188, - 189, -1, -1, -1, -1, -1, 2530, -1, -1, 3, - -1, -1, -1, -1, 8, -1, 2540, 11, -1, -1, - -1, 15, 16, 17, 18, 19, 20, 21, -1, -1, - -1, -1, -1, -1, -1, -1, 2560, -1, -1, -1, - -1, -1, 36, -1, -1, -1, 40, -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, 252, 253, 254, 255, 256, 257, 258, - 259, -1, -1, 262, 263, -1, -1, -1, -1, -1, - 3204, -1, -1, -1, -1, -1, 80, -1, -1, -1, - -1, -1, -1, 2617, -1, 2619, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3447, 3448, 3449, -1, -1, -1, -1, + -1, 498, -1, 2203, 501, 502, 503, -1, 505, 506, + 507, 508, 509, 510, -1, -1, 80, -1, 515, -1, + 3474, -1, -1, -1, -1, 176, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 193, -1, -1, -1, -1, 198, 498, -1, + -1, 501, 502, 503, -1, 505, 506, 507, 508, 509, + 510, 3515, -1, -1, -1, 515, -1, -1, -1, -1, + 221, 222, 2272, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 2282, 2283, -1, 236, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1888, -1, -1, -1, -1, -1, -1, - -1, 1896, 1897, -1, 1899, 1900, 1901, 1902, 1903, 1904, - -1, -1, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, - 1915, 1916, 1917, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 176, -1, -1, -1, 375, 376, -1, -1, - 2714, 2715, -1, -1, -1, -1, -1, -1, -1, 193, + -1, -1, 176, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 274, -1, -1, 277, -1, -1, 193, -1, -1, -1, -1, 198, -1, -1, -1, -1, -1, + 291, -1, -1, 294, -1, -1, -1, 2347, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 221, 222, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 2369, + 2370, 2371, 236, -1, 2374, 2375, 2376, 2377, 2378, 2379, + -1, -1, -1, 2383, 2384, 2385, 2386, 2387, 2388, 2389, + 2390, 2391, 2392, -1, -1, -1, -1, 2397, 2398, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2749, -1, 221, 222, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 2763, - -1, -1, 236, -1, 2768, 2769, -1, -1, -1, 2773, - -1, -1, -1, -1, 2778, -1, -1, 2781, 2782, -1, - -1, -1, 2786, 2787, -1, -1, 2790, -1, -1, -1, - -1, -1, -1, 2018, -1, -1, 2021, 2801, -1, -1, - 274, 470, 471, 277, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 291, -1, -1, - 294, -1, -1, -1, -1, 494, 495, 8, -1, -1, - 11, -1, -1, -1, 15, 16, -1, -1, 19, 20, - 21, 2845, 2067, -1, -1, -1, 2071, 2072, 2073, 2074, - 2075, 2076, 2077, 2078, -1, 36, -1, -1, -1, 2084, - 2085, -1, 2087, 2088, -1, 46, -1, -1, 2872, -1, - -1, -1, 53, -1, 2099, -1, -1, 2102, -1, -1, - -1, -1, -1, -1, -1, 2110, 2111, 2112, 2113, 2114, - 2115, 2116, 2117, 2118, 2119, -1, -1, -1, -1, 80, - 8, -1, -1, 11, -1, -1, -1, 15, 16, 17, - 18, 19, 20, 21, -1, -1, -1, 391, -1, -1, - 2145, -1, -1, -1, -1, -1, -1, -1, 36, -1, - -1, -1, 40, -1, -1, -1, -1, -1, 46, -1, - -1, -1, -1, -1, -1, 53, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 2961, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 80, 2198, -1, -1, -1, -1, -1, -1, + 274, -1, -1, 277, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 2425, -1, 291, -1, -1, + 294, 2431, -1, -1, 8, -1, -1, 11, -1, -1, + 391, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 176, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3009, -1, -1, -1, -1, - -1, -1, 193, -1, -1, -1, -1, 198, -1, -1, - -1, -1, -1, -1, 498, 3029, -1, 501, 502, 503, - -1, 505, 506, 507, 508, 509, 510, -1, -1, 3043, - 221, 222, 2267, -1, -1, -1, -1, -1, -1, -1, - 3054, 3055, 2277, 2278, 3058, 236, 3060, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 176, -1, + -1, -1, 36, -1, -1, 2465, -1, -1, -1, -1, + -1, -1, 46, -1, -1, -1, -1, -1, -1, 53, + -1, -1, -1, -1, 2484, -1, -1, 2487, 2488, -1, + -1, -1, -1, -1, -1, 2495, 2496, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 80, -1, -1, 2509, + 2510, 2511, 2512, -1, 2514, -1, -1, -1, 2518, -1, + -1, -1, -1, -1, -1, -1, -1, 391, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3085, -1, -1, -1, 193, -1, -1, -1, -1, - 198, -1, -1, 274, -1, -1, 277, -1, -1, -1, - -1, -1, -1, -1, -1, 3109, -1, -1, -1, -1, - 291, -1, -1, 221, 222, -1, -1, 2342, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 236, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 2364, - 2365, 2366, -1, -1, 2369, 2370, 2371, 2372, 2373, 2374, - -1, -1, -1, 2378, 2379, 2380, 2381, 2382, 2383, 2384, - 2385, 2386, 2387, -1, -1, -1, 274, 2392, 2393, 277, - -1, -1, -1, -1, -1, 3179, -1, -1, -1, -1, - -1, -1, -1, 291, -1, -1, 294, -1, -1, -1, - -1, -1, -1, -1, 3198, 2420, 8, -1, 3202, 11, - 2425, -1, 3206, 15, 16, 17, 18, 19, 20, 21, - 391, -1, -1, -1, 3218, -1, -1, -1, -1, 3223, - -1, 3225, -1, -1, 36, -1, -1, -1, 24, 3233, - -1, -1, -1, 2458, 46, -1, -1, -1, -1, -1, - -1, 53, -1, -1, -1, -1, -1, 3251, -1, -1, - -1, -1, 2477, -1, -1, 2480, 2481, -1, -1, -1, - -1, -1, -1, 2488, 2489, -1, -1, -1, 80, -1, - -1, -1, -1, -1, -1, -1, -1, 2502, 2503, 2504, - 2505, -1, 2507, 391, -1, 81, 2511, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 3300, -1, -1, -1, - -1, 97, -1, -1, -1, -1, 3310, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 498, -1, 3323, + -1, -1, -1, -1, -1, -1, -1, 498, -1, -1, 501, 502, 503, -1, 505, 506, 507, 508, 509, 510, + -1, -1, -1, -1, 515, -1, -1, -1, -1, -1, + -1, -1, 2572, -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, 176, -1, -1, -1, -1, -1, -1, -1, + 36, -1, -1, -1, -1, -1, -1, -1, -1, 193, + 46, -1, -1, -1, 198, -1, -1, 53, -1, -1, + -1, -1, -1, -1, 498, -1, -1, 501, 502, 503, + -1, 505, 506, 507, 508, 509, 510, 221, 222, -1, + -1, 515, -1, -1, 80, -1, -1, 8, -1, -1, + 11, -1, 236, -1, 15, 16, 17, 18, 19, 20, + 21, -1, -1, -1, -1, -1, -1, -1, -1, 2679, + -1, -1, -1, -1, -1, 36, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 46, -1, -1, -1, -1, + 274, 2701, 53, 277, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 291, -1, -1, + 294, -1, -1, -1, -1, -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2565, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 146, 3355, -1, -1, -1, -1, -1, -1, -1, -1, - 156, -1, -1, -1, 176, -1, -1, -1, -1, -1, - -1, -1, 168, -1, -1, -1, -1, 173, -1, -1, - -1, 193, -1, -1, -1, -1, 198, -1, -1, -1, - 498, -1, -1, 501, 502, 503, -1, 505, 506, 507, - 508, 509, 510, -1, -1, -1, 202, 515, -1, 221, - 222, -1, -1, -1, -1, -1, -1, -1, 8, -1, - -1, 11, -1, -1, 236, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3445, 3446, 3447, -1, 2670, 36, -1, -1, 245, - -1, -1, -1, 249, -1, -1, 46, -1, -1, -1, - -1, -1, 274, 53, -1, 277, -1, -1, 3472, 2694, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 291, - -1, -1, 294, -1, -1, -1, -1, -1, -1, -1, - 80, -1, 8, -1, -1, 11, -1, -1, -1, 15, - 16, 17, 18, 19, 20, 21, -1, -1, -1, 3513, - -1, -1, -1, -1, -1, -1, -1, 313, -1, -1, - 36, -1, -1, 319, -1, 2750, -1, 2752, -1, -1, - 46, -1, -1, 2758, -1, -1, -1, 53, 334, -1, - -1, -1, 2767, -1, -1, 2770, -1, 2772, -1, -1, - -1, 2776, -1, -1, 2779, 2780, -1, -1, 2783, 2784, - -1, -1, -1, -1, 80, -1, 2791, -1, -1, -1, - -1, 367, -1, -1, 370, 2800, -1, -1, -1, 391, - -1, -1, -1, -1, 8, 381, 176, 11, 384, -1, - 2815, 15, 16, 17, 18, 19, 20, 21, -1, -1, - -1, -1, -1, 193, -1, -1, 402, -1, 198, -1, - -1, -1, 36, -1, -1, -1, -1, -1, -1, -1, - 416, -1, 46, -1, -1, -1, 422, 423, 2853, 53, - -1, 221, 222, -1, -1, -1, -1, 433, -1, -1, - -1, -1, -1, 439, -1, -1, 236, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 80, -1, -1, -1, - 176, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 466, -1, -1, -1, -1, -1, -1, 193, -1, -1, - -1, -1, 198, -1, 274, -1, 498, 277, -1, 501, - 502, 503, -1, 505, 506, 507, 508, 509, 510, -1, - -1, 291, -1, 515, 294, 221, 222, -1, -1, -1, + 8, -1, -1, 11, -1, -1, -1, 15, 16, -1, + 176, 19, 20, 21, -1, -1, -1, 2757, -1, 2759, + -1, -1, -1, -1, -1, 2765, -1, 193, 36, -1, + -1, -1, 198, -1, 2774, -1, -1, 2777, 46, 2779, + -1, -1, -1, 2783, -1, 53, 2786, 2787, -1, -1, + 2790, 2791, -1, -1, -1, 221, 222, -1, 2798, -1, + -1, -1, -1, -1, -1, -1, -1, 2807, -1, -1, + 236, -1, 80, -1, -1, -1, -1, 391, -1, -1, + -1, -1, 2822, -1, -1, 176, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 236, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 193, -1, -1, -1, -1, 198, 274, -1, + -1, 277, -1, -1, -1, -1, -1, -1, -1, -1, + 2860, -1, -1, -1, -1, 291, -1, -1, 294, -1, + 221, 222, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 236, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 176, -1, + 68, 69, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 274, 498, 193, 277, 501, 502, 503, + 198, 505, 506, 507, 508, 509, 510, -1, -1, -1, + 291, 515, -1, 294, -1, -1, -1, -1, 68, 69, + -1, 109, 110, 221, 222, 113, 114, -1, -1, -1, + -1, -1, -1, -1, -1, 391, -1, -1, 236, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 176, -1, -1, -1, -1, -1, 274, -1, - -1, 277, -1, -1, -1, -1, -1, 2992, 2993, 193, - -1, -1, -1, -1, 198, 291, -1, -1, 294, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, + 110, -1, -1, 113, 114, -1, -1, -1, -1, 2999, + 3000, -1, -1, -1, -1, -1, 274, -1, -1, 277, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 3017, 3018, -1, -1, -1, 221, 222, -1, - -1, 391, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 236, -1, -1, -1, -1, 3042, -1, -1, - -1, 3046, -1, 3048, 3049, 3050, -1, -1, 3053, -1, - -1, 3056, 3057, -1, -1, -1, -1, -1, -1, -1, - 3065, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 274, -1, -1, 277, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 291, -1, -1, - 294, -1, -1, -1, -1, 391, -1, -1, -1, -1, - -1, 3106, -1, -1, -1, -1, -1, 3112, -1, -1, + -1, -1, -1, 291, 3024, 3025, 294, -1, -1, -1, + 188, 189, -1, -1, -1, -1, -1, -1, -1, -1, + 391, -1, -1, -1, -1, -1, -1, -1, 3048, -1, + -1, -1, 3052, -1, 3054, 3055, 3056, -1, -1, 3059, + -1, -1, 3062, 3063, -1, -1, -1, -1, 188, 189, + -1, 3071, 498, -1, -1, 501, 502, 503, -1, 505, + 506, 507, 508, 509, 510, -1, -1, -1, -1, 515, + -1, -1, -1, -1, 252, 253, 254, 255, 256, 257, + 258, 259, -1, -1, 262, 263, -1, -1, -1, -1, + -1, -1, 3112, -1, -1, -1, -1, -1, 3118, -1, + -1, -1, -1, 391, -1, -1, -1, -1, -1, -1, + -1, 3131, 252, 253, 254, 255, 256, 257, 258, 259, + -1, -1, 262, 263, -1, -1, -1, 498, -1, -1, + 501, 502, 503, -1, 505, 506, 507, 508, 509, 510, + -1, -1, -1, -1, 515, 3165, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3125, -1, -1, -1, -1, -1, -1, -1, 498, -1, - -1, 501, 502, 503, -1, 505, 506, 507, 508, 509, - 510, -1, -1, -1, -1, 515, -1, -1, -1, -1, - -1, -1, -1, 3158, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 3192, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3186, -1, -1, -1, -1, -1, 391, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 375, 376, -1, + -1, -1, -1, -1, -1, 3225, 3226, 3227, -1, -1, + 498, -1, -1, 501, 502, 503, -1, 505, 506, 507, + 508, 509, 510, -1, -1, 3245, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 375, 376, 3257, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 498, -1, -1, 501, 502, 503, -1, 505, - 506, 507, 508, 509, 510, 3220, 3221, 3222, -1, 515, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3240, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3252, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3303, -1, -1, -1, -1, -1, -1, + -1, -1, 470, 471, -1, -1, -1, -1, -1, -1, + 3320, -1, -1, -1, -1, -1, -1, -1, -1, 3329, + -1, -1, -1, -1, -1, -1, 494, 495, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 470, 471, -1, -1, 3354, -1, 514, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 3297, -1, 498, -1, -1, 501, 502, 503, - -1, 505, 506, 507, 508, 509, 510, -1, -1, -1, - 3315, 515, -1, -1, -1, -1, -1, -1, -1, -1, - 3325, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 494, 495, -1, -1, -1, -1, + 3380, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3350, -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, 3423, -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, 3477, 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, -1, 162, 163, 164, 165, -1, + 167, -1, 169, 170, -1, 172, 173, 174, 175, 176, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, 391, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, 464, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, -1, -1, -1, -1, -1, -1, 505, 506, + 507, -1, -1, -1, -1, 512, -1, 514, -1, -1, + -1, -1, 519, 520, -1, 522, 523, 524, 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, -1, 162, 163, 164, + 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, + 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, + -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, + 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, + 235, 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, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, + -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, + -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, + -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, + 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, + 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, + 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, + 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, + 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, + 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, + -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, + 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, + 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, + -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, + 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, + -1, -1, -1, -1, 519, 520, -1, 522, 523, 524, + 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, -1, 162, + 163, 164, 165, -1, 167, -1, 169, 170, 171, 172, + 173, 174, 175, 176, 177, -1, 179, -1, 181, 182, + 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, + 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, + 233, 234, 235, 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, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, + 293, -1, -1, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, -1, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, + 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, + 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, + 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, -1, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + -1, 414, 415, 416, 417, 418, 419, 420, 421, 422, + 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 443, -1, -1, 446, 447, 448, 449, 450, 451, 452, + 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, + 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, + -1, 474, -1, 476, 477, 478, 479, 480, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 498, -1, 500, -1, -1, + -1, -1, 505, 506, 507, -1, -1, -1, -1, 512, + -1, 514, 515, -1, -1, -1, 519, 520, -1, 522, + 523, 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, -1, + 162, 163, 164, 165, -1, 167, -1, 169, 170, 171, + 172, 173, 174, 175, 176, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, -1, + -1, 233, 234, 235, 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, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, -1, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, 361, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, -1, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, 449, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, 464, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, 476, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, -1, 500, -1, + -1, -1, -1, 505, 506, 507, -1, -1, -1, -1, + 512, -1, 514, -1, -1, -1, -1, 519, 520, -1, + 522, 523, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3376, -1, 3, 4, 5, 6, 7, 8, 9, + -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, + -1, 162, 163, 164, 165, -1, 167, -1, 169, 170, + 171, 172, 173, 174, 175, 176, 177, -1, 179, -1, + 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, -1, 199, 200, + 201, 202, 203, 204, 205, -1, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + -1, -1, 233, 234, 235, 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, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, + 291, 292, 293, -1, -1, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, -1, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, -1, 329, 330, + 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, + 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, + 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, -1, + 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, + 391, 392, 393, 394, 395, -1, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, -1, -1, 414, 415, 416, 417, 418, 419, 420, + 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, -1, -1, 446, 447, 448, 449, 450, + 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, + 461, -1, 463, 464, 465, 466, 467, 468, 469, 470, + 471, -1, -1, 474, -1, 476, 477, 478, 479, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, -1, 500, + -1, -1, -1, -1, 505, 506, 507, -1, -1, -1, + -1, 512, -1, 514, -1, -1, -1, -1, 519, 520, + -1, 522, 523, 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, 3420, 46, 47, 48, 49, + 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, - 3475, 101, 102, 103, 104, 105, 106, 107, 108, 109, + -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, + 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, -1, 162, 163, 164, 165, -1, 167, -1, 169, @@ -397678,7 +402681,7 @@ static const yytype_int16 yycheck[] = 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, -1, - -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, + 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, 418, 419, @@ -397686,19 +402689,71 @@ static const yytype_int16 yycheck[] = 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, - 460, 461, -1, 463, 464, 465, 466, 467, 468, 469, + 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, 505, 506, 507, -1, -1, - -1, -1, 512, -1, 514, -1, -1, -1, -1, 519, - 520, 521, 522, -1, 524, 3, 4, 5, 6, 7, + -1, -1, 512, -1, 514, 515, -1, -1, -1, 519, + 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, 167, -1, + 169, 170, 171, 172, 173, 174, 175, 176, 177, -1, + 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, -1, + 199, 200, 201, 202, 203, 204, 205, -1, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, + -1, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, -1, -1, 233, 234, 235, 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, + 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, -1, 287, 288, + -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, -1, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, + 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + 379, -1, 381, 382, 383, 384, 385, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, -1, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, 412, -1, 414, 415, 416, 417, 418, + 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, + -1, 430, 431, 432, 433, 434, 435, 436, 437, 438, + 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, + 449, 450, 451, 452, 453, -1, 455, 456, 457, 458, + 459, 460, 461, -1, 463, 464, 465, 466, 467, 468, + 469, 470, 471, -1, -1, 474, -1, 476, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, -1, + -1, 500, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 512, -1, 514, -1, -1, -1, -1, + 519, 520, -1, 522, 523, 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, + 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, @@ -397709,13 +402764,13 @@ 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, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, 170, -1, 172, 173, 174, 175, 176, 177, + -1, 169, 170, 171, 172, 173, 174, 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, -1, -1, 233, 234, 235, 236, -1, + 228, 229, 230, -1, 232, 233, 234, 235, 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, @@ -397735,7 +402790,7 @@ static const yytype_int16 yycheck[] = 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, 435, 436, 437, + -1, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, 466, 467, @@ -397744,166 +402799,62 @@ static const yytype_int16 yycheck[] = 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, -1, -1, -1, - -1, 519, 520, 521, 522, -1, 524, 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, -1, 162, 163, 164, 165, - -1, 167, -1, 169, 170, 171, 172, 173, 174, 175, - 176, 177, -1, 179, -1, 181, 182, 183, 184, -1, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, - -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, -1, 218, -1, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, -1, -1, 233, 234, 235, - 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, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, -1, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, - 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, - 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, -1, 381, 382, 383, 384, 385, - 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, - -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, -1, 414, 415, - 416, 417, 418, 419, 420, 421, 422, 423, -1, 425, - 426, 427, -1, -1, 430, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, - 446, 447, 448, 449, 450, 451, 452, 453, -1, 455, - 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, - 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, -1, 500, -1, -1, -1, -1, 505, - 506, 507, -1, -1, -1, -1, 512, -1, 514, 515, - -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, 165, - -1, 167, -1, 169, 170, 171, 172, 173, 174, 175, - 176, 177, -1, 179, -1, 181, 182, 183, 184, -1, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, - -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, -1, 218, -1, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, -1, -1, 233, 234, 235, - 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, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, -1, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, - 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, - 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, -1, 381, 382, 383, 384, 385, - 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, - -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, -1, 414, 415, - 416, 417, 418, 419, 420, 421, 422, 423, -1, 425, - 426, 427, -1, -1, 430, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, - 446, 447, 448, 449, 450, 451, 452, 453, -1, 455, - 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, - 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, -1, 500, -1, -1, -1, -1, 505, - 506, 507, -1, -1, -1, -1, 512, -1, 514, -1, - -1, -1, -1, 519, 520, 521, 522, 3, 4, 5, + -1, 519, 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, + 167, -1, 169, 170, -1, 172, 173, 174, 175, 176, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, 380, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, 391, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, -1, -1, -1, -1, -1, -1, 505, 506, + 507, -1, -1, -1, -1, 512, -1, 514, -1, -1, + -1, -1, 519, 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, - -1, 167, -1, 169, 170, 171, 172, 173, 174, 175, - 176, 177, -1, 179, -1, 181, 182, 183, 184, -1, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, - -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, -1, 218, -1, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, -1, -1, 233, 234, 235, - 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, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, -1, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, - 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, - 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, -1, 381, 382, 383, 384, 385, - 386, 387, 388, 389, -1, 391, 392, 393, 394, 395, - -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, - 416, 417, 418, 419, 420, 421, 422, 423, -1, 425, - 426, 427, -1, -1, 430, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, - 446, 447, 448, 449, 450, 451, 452, 453, -1, 455, - 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, - 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, -1, 500, -1, -1, -1, -1, 505, - 506, 507, -1, -1, -1, -1, 512, -1, 514, -1, - -1, -1, -1, 519, 520, 521, 522, 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, @@ -397913,7 +402864,7 @@ static const yytype_int16 yycheck[] = 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, + -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, -1, 162, 163, 164, 165, @@ -397946,69 +402897,19 @@ static const yytype_int16 yycheck[] = 426, 427, -1, -1, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, - 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, + 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, 515, - -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, 165, - -1, 167, -1, 169, 170, 171, 172, 173, 174, 175, - 176, 177, -1, 179, -1, 181, 182, 183, 184, -1, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, - -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, -1, 218, -1, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, -1, -1, 233, 234, 235, - 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, 269, 270, 271, 272, 273, -1, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, -1, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, - 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, - 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, -1, 381, 382, 383, 384, 385, - 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, - -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, -1, 414, 415, - 416, 417, 418, 419, 420, 421, 422, 423, -1, 425, - 426, 427, -1, -1, 430, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, - 446, 447, 448, 449, 450, 451, 452, 453, -1, 455, - 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, - 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, -1, -1, 500, -1, -1, -1, 3, 4, - 5, 6, 7, 8, 9, 10, 512, -1, 514, -1, - -1, -1, -1, 519, 520, 521, 522, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, 39, -1, -1, 42, 43, 44, + -1, -1, -1, 519, 520, -1, 522, 523, 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, 58, 59, 60, 61, 62, 63, 64, + 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, @@ -398019,13 +402920,13 @@ static const yytype_int16 yycheck[] = 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, 171, 172, 173, 174, + 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, + 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, 235, 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, @@ -398042,10 +402943,10 @@ static const yytype_int16 yycheck[] = 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, 429, 430, 431, 432, 433, 434, + 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, @@ -398054,11 +402955,480 @@ static const yytype_int16 yycheck[] = 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 3, 4, + -1, -1, -1, -1, 519, 520, -1, 522, 523, 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, -1, 162, 163, + 164, 165, -1, 167, -1, 169, 170, -1, 172, 173, + 174, 175, 176, 177, -1, 179, -1, 181, 182, 183, + 184, -1, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, + 204, 205, -1, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, -1, 218, -1, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, -1, -1, 233, + 234, 235, 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, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, + -1, -1, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + -1, -1, -1, -1, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, + 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, + -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, -1, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, -1, 380, 381, 382, 383, + 384, 385, 386, 387, 388, 389, -1, 391, 392, 393, + 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, + 414, 415, -1, 417, 418, 419, 420, 421, 422, 423, + -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, + -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, + 464, 465, 466, 467, 468, 469, 470, 471, -1, -1, + 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, -1, -1, -1, -1, -1, + -1, 505, 506, 507, -1, -1, -1, -1, 512, -1, + 514, 515, -1, -1, -1, 519, 520, -1, 522, 523, + 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, -1, 162, + 163, 164, 165, -1, 167, -1, 169, 170, -1, 172, + 173, 174, 175, 176, 177, -1, 179, -1, 181, 182, + 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, + 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, + 233, 234, 235, 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, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, + 293, -1, -1, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, -1, -1, -1, -1, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, + 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, + 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, + 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, -1, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, + 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, + -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, + 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, + 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, + 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, + -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 498, -1, -1, -1, -1, + -1, -1, 505, 506, 507, -1, -1, -1, -1, 512, + -1, 514, -1, -1, -1, -1, 519, 520, -1, 522, + 523, 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, -1, + 162, 163, 164, 165, -1, 167, -1, 169, 170, -1, + 172, 173, 174, 175, 176, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, -1, + -1, 233, 234, 235, 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, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, 361, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, 391, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, 418, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, 464, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, -1, -1, -1, + -1, -1, -1, 505, 506, 507, -1, -1, -1, -1, + 512, -1, 514, -1, -1, -1, -1, 519, 520, -1, + 522, 523, 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, + -1, 162, 163, 164, 165, -1, 167, -1, 169, 170, + -1, 172, 173, 174, 175, 176, 177, -1, 179, -1, + 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, -1, 199, 200, + 201, 202, 203, 204, 205, -1, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + -1, -1, 233, 234, 235, 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, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, + 291, 292, 293, -1, -1, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, -1, 329, 330, + 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, + 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, + 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, -1, -1, + 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, + 391, 392, 393, 394, 395, -1, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, -1, -1, 414, 415, -1, 417, 418, 419, 420, + 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, + 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, + 461, -1, 463, 464, 465, 466, 467, 468, 469, 470, + 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, -1, -1, + -1, -1, -1, -1, 505, 506, 507, -1, -1, -1, + -1, 512, -1, 514, -1, -1, -1, -1, 519, 520, + -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, 167, -1, 169, + 170, 171, 172, 173, 174, 175, 176, 177, -1, 179, + -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, -1, 199, + 200, 201, 202, 203, 204, 205, -1, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, -1, 218, -1, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, -1, -1, 233, 234, 235, 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, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, + -1, 291, 292, 293, -1, -1, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, -1, -1, -1, -1, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, -1, 329, + 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, + 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, -1, + -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, + -1, 391, 392, 393, 394, 395, -1, 397, 398, 399, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, -1, -1, 414, 415, -1, 417, 418, 419, + 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, + 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, + 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, + 460, 461, -1, 463, 464, 465, 466, 467, 468, 469, + 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, -1, + -1, -1, -1, -1, -1, 505, 506, 507, -1, -1, + -1, -1, 512, -1, 514, -1, -1, -1, -1, 519, + 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, 167, -1, + 169, 170, -1, 172, 173, 174, 175, 176, 177, -1, + 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, -1, + 199, 200, 201, 202, 203, 204, 205, -1, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, + -1, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, -1, -1, 233, 234, 235, 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, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, -1, 287, 288, + -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, + 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, + 389, -1, 391, 392, 393, 394, 395, -1, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, -1, -1, 414, 415, -1, 417, 418, + 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, + -1, 430, 431, 432, 433, 434, 435, 436, 437, 438, + 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, + -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, + 459, 460, 461, -1, 463, 464, 465, 466, 467, 468, + 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, + -1, -1, -1, -1, -1, -1, 505, 506, 507, -1, + -1, -1, -1, 512, -1, 514, 515, -1, -1, -1, + 519, 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, 167, + -1, 169, 170, -1, 172, 173, 174, 175, 176, 177, + -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, -1, + 218, -1, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, -1, 287, + 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, + 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, + 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, -1, -1, 414, 415, 416, 417, + 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, + -1, -1, 430, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, + 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, + 458, 459, 460, 461, -1, 463, 464, 465, 466, 467, + 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, + 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, -1, -1, -1, -1, -1, -1, 505, 506, 507, + -1, -1, -1, -1, 512, -1, 514, -1, -1, -1, + -1, 519, 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, + 167, -1, 169, 170, -1, 172, 173, 174, 175, 176, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, 391, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, 464, 465, 466, + 467, 468, 469, 470, 471, -1, 473, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, -1, -1, -1, -1, -1, -1, 505, 506, + 507, -1, -1, -1, -1, 512, -1, 514, -1, -1, + -1, -1, 519, 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, + -1, 167, -1, 169, 170, -1, 172, 173, 174, 175, + 176, 177, -1, 179, -1, 181, 182, 183, 184, -1, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, + -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, -1, 218, -1, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, -1, -1, 233, 234, 235, + 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, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, -1, -1, + -1, -1, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, + 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, + 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, + 386, 387, 388, 389, -1, 391, 392, 393, 394, 395, + -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, + -1, 417, 418, 419, 420, 421, 422, 423, -1, 425, + 426, 427, -1, -1, 430, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, + 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, + 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, + 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, + -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, -1, -1, -1, -1, -1, -1, 505, + 506, 507, -1, -1, -1, -1, 512, -1, 514, -1, + -1, -1, -1, 519, 520, -1, 522, 523, 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, -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, @@ -398092,25 +403462,494 @@ static const yytype_int16 yycheck[] = 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, 380, 381, 382, 383, 384, + 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, + 415, 416, 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 3, 4, + -1, -1, -1, -1, 519, 520, -1, 522, 523, 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, -1, 162, 163, + 164, 165, -1, 167, -1, 169, 170, -1, 172, 173, + 174, 175, 176, 177, -1, 179, -1, 181, 182, 183, + 184, -1, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, + 204, 205, -1, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, -1, 218, -1, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, -1, -1, 233, + 234, 235, 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, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, + -1, -1, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + -1, -1, -1, -1, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, + 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, + -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, -1, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, -1, -1, 381, 382, 383, + 384, 385, 386, 387, 388, 389, -1, 391, 392, 393, + 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, + 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, + -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, + -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, + 464, 465, 466, 467, 468, 469, 470, 471, -1, -1, + 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, -1, -1, -1, -1, -1, + -1, 505, 506, 507, -1, -1, -1, -1, 512, -1, + 514, -1, -1, -1, -1, 519, 520, -1, 522, 523, + 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, -1, 162, + 163, 164, 165, -1, 167, -1, 169, 170, -1, 172, + 173, 174, 175, 176, 177, -1, 179, -1, 181, 182, + 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, + 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, + 233, 234, 235, 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, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, + 293, -1, -1, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, -1, -1, -1, -1, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, + 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, + 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, + 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, + 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, + 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, + -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, + 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, + 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, + 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, + -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 498, -1, -1, -1, -1, + -1, -1, 505, 506, 507, -1, -1, -1, -1, 512, + -1, 514, -1, -1, -1, -1, 519, 520, -1, 522, + 523, 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, -1, + 162, 163, 164, 165, -1, 167, -1, 169, 170, -1, + 172, 173, 174, 175, 176, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, -1, + -1, 233, 234, 235, 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, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, 361, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, 391, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, 418, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, 464, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, -1, -1, -1, + -1, -1, -1, 505, 506, 507, -1, -1, -1, -1, + 512, -1, 514, -1, -1, -1, -1, 519, 520, -1, + 522, 523, 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, + -1, 162, 163, 164, 165, -1, 167, -1, 169, 170, + -1, 172, 173, 174, 175, 176, 177, -1, 179, -1, + 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, -1, 199, 200, + 201, 202, 203, 204, 205, -1, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + -1, -1, 233, 234, 235, 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, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, + 291, 292, 293, -1, -1, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, -1, 329, 330, + 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, + 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, + 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, -1, -1, + 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, + 391, 392, 393, 394, 395, -1, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, -1, -1, 414, 415, -1, 417, 418, 419, 420, + 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, + 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, + 461, -1, 463, 464, 465, 466, 467, 468, 469, 470, + 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, -1, -1, + -1, -1, -1, -1, 505, 506, 507, -1, -1, -1, + -1, 512, -1, 514, -1, -1, -1, -1, 519, 520, + -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, 167, -1, 169, + 170, -1, 172, 173, 174, 175, 176, 177, -1, 179, + -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, -1, 199, + 200, 201, 202, 203, 204, 205, -1, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, -1, 218, -1, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, -1, -1, 233, 234, 235, 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, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, + -1, 291, 292, 293, -1, -1, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, -1, -1, -1, -1, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, -1, 329, + 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, + 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, -1, + -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, + -1, 391, 392, 393, 394, 395, -1, 397, 398, 399, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, -1, -1, 414, 415, -1, 417, 418, 419, + 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, + 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, + 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, + 460, 461, -1, 463, 464, 465, 466, 467, 468, 469, + 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, -1, + -1, -1, -1, -1, -1, 505, 506, 507, -1, -1, + -1, -1, 512, -1, 514, -1, -1, -1, -1, 519, + 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, 167, -1, + 169, 170, -1, 172, 173, 174, 175, 176, 177, -1, + 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, -1, + 199, 200, 201, 202, 203, 204, 205, -1, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, + -1, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, -1, -1, 233, 234, 235, 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, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, -1, 287, 288, + -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, + 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, + 389, -1, 391, 392, 393, 394, 395, -1, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, -1, -1, 414, 415, -1, 417, 418, + 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, + -1, 430, 431, 432, 433, 434, 435, 436, 437, 438, + 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, + -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, + 459, 460, 461, -1, 463, 464, 465, 466, 467, 468, + 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, + -1, -1, -1, -1, -1, -1, 505, 506, 507, -1, + -1, -1, -1, 512, -1, 514, -1, -1, -1, -1, + 519, 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, 167, + -1, 169, 170, -1, 172, 173, 174, 175, 176, 177, + -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, -1, + 218, -1, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, -1, 287, + 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, + 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, + 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, + 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, + -1, -1, 430, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, + 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, + 458, 459, 460, 461, -1, 463, 464, 465, 466, 467, + 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, + 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, -1, -1, -1, -1, -1, -1, 505, 506, 507, + -1, -1, -1, -1, 512, -1, 514, -1, -1, -1, + -1, 519, 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, + 167, -1, 169, 170, -1, 172, 173, 174, 175, 176, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, 391, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, 464, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, -1, -1, -1, -1, -1, -1, 505, 506, + 507, -1, -1, -1, -1, 512, -1, 514, -1, -1, + -1, -1, 519, 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, + -1, 167, -1, 169, 170, -1, 172, 173, 174, 175, + 176, 177, -1, 179, -1, 181, 182, 183, 184, -1, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, + -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, -1, 218, -1, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, -1, -1, 233, 234, 235, + 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, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, -1, -1, + -1, -1, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, + 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, + 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, + 386, 387, 388, 389, -1, 391, 392, 393, 394, 395, + -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, + -1, 417, 418, 419, 420, 421, 422, 423, -1, 425, + 426, 427, -1, -1, 430, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, + 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, + 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, + 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, + -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, -1, -1, -1, -1, -1, -1, 505, + 506, 507, -1, -1, -1, -1, 512, -1, 514, -1, + -1, -1, -1, 519, 520, -1, 522, 523, 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, -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, @@ -398144,7 +403983,7 @@ static const yytype_int16 yycheck[] = 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, 380, 381, 382, 383, 384, + 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, @@ -398158,231 +403997,736 @@ static const yytype_int16 yycheck[] = 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - 515, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, 380, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - 515, -1, -1, -1, 519, 520, 521, 522, 3, 4, - 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, + -1, -1, -1, -1, 519, 520, -1, 522, 523, 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, -1, 162, 163, + 164, 165, -1, 167, -1, 169, 170, -1, 172, 173, + 174, 175, 176, 177, -1, 179, -1, 181, 182, 183, + 184, -1, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, + 204, 205, -1, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, -1, 218, -1, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, -1, -1, 233, + 234, 235, 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, 269, 270, 271, 272, 273, + -1, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, + -1, -1, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + -1, -1, -1, -1, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, + 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, + -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, -1, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, -1, -1, 381, 382, 383, + 384, 385, 386, 387, 388, 389, -1, 391, 392, 393, + 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, + 414, 415, -1, 417, 418, 419, 420, 421, 422, 423, + -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, + -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, + 464, 465, 466, 467, 468, 469, 470, 471, -1, -1, + 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, -1, -1, -1, -1, -1, -1, + -1, 505, 506, -1, -1, -1, -1, -1, 512, -1, + 514, -1, -1, -1, -1, 519, 520, -1, 522, 523, + 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, -1, 162, + 163, 164, 165, -1, 167, -1, 169, 170, -1, 172, + 173, 174, 175, 176, 177, -1, 179, -1, 181, 182, + 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, + 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, + 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, + 233, 234, 235, 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, 269, 270, 271, 272, + 273, -1, 275, 276, -1, 278, 279, 280, 281, 282, + 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, + 293, -1, -1, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, -1, -1, -1, -1, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, + 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, + 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, + 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, + 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, + 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, + -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, + 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, + 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, + 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, + -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 498, -1, -1, -1, -1, + -1, -1, 505, 506, 507, -1, -1, -1, -1, 512, + -1, 514, -1, -1, -1, -1, 519, 520, -1, 522, + 523, 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, -1, + 162, 163, 164, 165, -1, 167, -1, 169, 170, -1, + 172, 173, 174, 175, 176, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, -1, + -1, 233, 234, 235, 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, 269, 270, 271, + 272, 273, -1, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, 361, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, 391, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, 418, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, 464, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, -1, -1, -1, -1, + -1, -1, -1, 505, 506, -1, -1, -1, -1, -1, + 512, -1, 514, -1, -1, -1, -1, 519, 520, -1, + 522, 523, 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, + -1, 162, 163, 164, 165, -1, 167, -1, 169, 170, + -1, 172, 173, 174, 175, 176, 177, -1, 179, -1, + 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, -1, 199, 200, + 201, 202, 203, 204, 205, -1, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, + -1, 222, 223, 224, 225, 226, 227, 228, 229, 230, + -1, -1, 233, 234, 235, 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, 269, 270, + 271, 272, 273, -1, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, + 291, 292, 293, -1, -1, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, -1, 329, 330, + 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, + 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, + 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, -1, -1, + 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, + 391, 392, 393, 394, 395, -1, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, -1, -1, 414, 415, -1, 417, 418, 419, 420, + 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, + 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, + 461, -1, 463, 464, 465, 466, 467, 468, 469, 470, + 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, -1, -1, -1, + -1, -1, -1, -1, 505, 506, -1, -1, -1, -1, + -1, 512, -1, 514, -1, -1, -1, -1, 519, 520, + -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, 167, -1, 169, + 170, -1, 172, 173, 174, 175, 176, 177, -1, 179, + 180, 181, 182, 183, 184, -1, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, -1, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, -1, 218, -1, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, -1, -1, 233, 234, 235, 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, 269, + 270, 271, 272, 273, -1, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, + -1, 291, 292, 293, -1, -1, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, -1, -1, -1, -1, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, -1, 329, + 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, + 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, -1, + -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, + -1, 391, 392, 393, 394, 395, -1, 397, 398, 399, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, -1, -1, 414, 415, -1, 417, 418, 419, + 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, + 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, + 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, + 460, 461, -1, 463, 464, 465, 466, 467, 468, 469, + 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 512, -1, 514, -1, -1, -1, -1, 519, + 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, 167, -1, + 169, 170, -1, 172, 173, 174, 175, 176, 177, -1, + 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, -1, + 199, 200, 201, 202, 203, 204, 205, -1, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, + -1, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, -1, -1, 233, 234, 235, 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, + 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, -1, 287, 288, + -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, + 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, + 389, -1, 391, 392, 393, 394, 395, -1, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, -1, -1, 414, 415, -1, 417, 418, + 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, + -1, 430, 431, 432, 433, 434, 435, 436, 437, 438, + 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, + -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, + 459, 460, 461, -1, 463, 464, 465, 466, 467, 468, + 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 512, -1, 514, -1, -1, -1, -1, + 519, 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, 167, + -1, 169, 170, -1, 172, 173, 174, 175, 176, 177, + -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, -1, + 218, -1, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, -1, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, -1, 287, + 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, + 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, + 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, + 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, + -1, -1, 430, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, + 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, + 458, 459, 460, 461, -1, 463, 464, 465, 466, 467, + 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, + 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 512, -1, 514, -1, -1, -1, + -1, 519, 520, -1, 522, 523, 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, -1, 162, 163, 164, 165, -1, + 167, -1, 169, 170, -1, 172, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, 224, 225, 226, + 227, 228, 229, 230, -1, -1, 233, 234, 235, -1, + -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, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, 279, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, 464, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, -1, -1, -1, -1, -1, -1, -1, 505, 506, + 507, -1, 3, 4, 5, 512, -1, 514, 9, -1, + -1, -1, 519, 520, -1, 522, 523, -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, + -1, 162, 163, 164, 165, -1, 167, -1, 169, 170, + -1, 172, 173, 174, 175, 176, 177, -1, 179, -1, + 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, -1, 199, 200, + 201, 202, 203, 204, 205, -1, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + -1, -1, 233, 234, 235, 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, 269, 270, + 271, 272, 273, -1, 275, 276, 277, 278, -1, 280, + 281, 282, 283, 284, 285, -1, 287, 288, 289, -1, + 291, 292, 293, -1, -1, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, -1, 329, 330, + 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, + 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, + 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, -1, 380, + 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, + 391, 392, 393, 394, 395, -1, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, -1, -1, 414, 415, -1, 417, 418, 419, 420, + 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, + 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, + 461, -1, 463, 464, 465, 466, 467, 468, 469, 470, + 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, -1, -1, -1, + -1, 3, -1, -1, 505, 506, 507, -1, -1, -1, + -1, -1, -1, 514, -1, -1, -1, -1, -1, 520, + 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, -1, 160, 161, + 162, 163, 164, 165, 166, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, 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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, 286, 287, 288, -1, -1, 291, + 292, 293, -1, 295, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, 444, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 3, -1, 5, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 515, -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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 514, 515, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, 170, 171, + 172, 173, 174, 175, 176, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, -1, + -1, 233, 234, 235, 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, 269, 270, 271, + 272, 273, -1, 275, 276, 277, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, -1, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 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, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, -1, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, 449, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, 464, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, 476, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, -1, 3, 500, 5, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 514, -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, -1, 160, -1, 162, 163, 164, 165, + -1, 167, -1, 169, 170, 171, 172, 173, 174, 175, + 176, 177, -1, 179, -1, 181, 182, 183, 184, -1, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, + -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, -1, 218, -1, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, 233, 234, 235, + 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, 269, 270, 271, 272, 273, -1, 275, + 276, 277, 278, -1, 280, 281, 282, 283, 284, 285, + -1, 287, 288, -1, 290, 291, 292, 293, -1, -1, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, -1, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, + 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, + 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, -1, 381, 382, 383, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, -1, 414, 415, + 416, 417, 418, 419, 420, 421, 422, 423, -1, 425, + 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, + 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, + 446, 447, 448, 449, 450, 451, 452, 453, -1, 455, + 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, + 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, + 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, -1, 3, 500, 5, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 514, -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, -1, + 160, -1, 162, 163, 164, 165, -1, 167, -1, 169, + 170, -1, 172, 173, 174, 175, 176, 177, -1, 179, + -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, -1, 199, + 200, 201, 202, 203, 204, 205, -1, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, -1, 218, -1, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, -1, 233, 234, 235, 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, 269, + 270, 271, 272, 273, -1, 275, 276, 277, 278, -1, + 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, + 290, 291, 292, 293, -1, -1, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, -1, -1, -1, -1, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, -1, 329, + 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, + 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, -1, + -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, + -1, 391, 392, 393, 394, 395, -1, 397, 398, 399, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, -1, -1, 414, 415, -1, 417, 418, 419, + 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, + 430, 431, 432, 433, 434, -1, 436, 437, 438, 439, + 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, + 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, + 460, 461, -1, 463, 464, 465, 466, 467, 468, 469, + 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 3, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 514, -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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, 380, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -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, - 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, + -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, -1, 120, 121, 122, 123, 124, + 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, -1, 162, 163, 164, + 155, 156, 157, 158, -1, 160, -1, 162, 163, 164, 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, @@ -398393,60 +404737,8 @@ static const yytype_int16 yycheck[] = 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, 171, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 265, 266, 267, 268, 269, 270, 271, 272, 273, -1, + 275, 276, 277, 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, @@ -398462,1258 +404754,363 @@ static const yytype_int16 yycheck[] = 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, + -1, 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 3, 4, - 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, + 495, 496, 497, 3, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 514, + -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, -1, + 160, -1, 162, 163, 164, 165, -1, 167, -1, 169, + 170, -1, 172, 173, 174, 175, 176, 177, -1, 179, + -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, -1, 199, + 200, 201, 202, 203, 204, 205, -1, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, -1, 218, -1, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, -1, -1, 233, 234, 235, 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, 269, + 270, 271, 272, 273, -1, 275, 276, 277, 278, -1, + 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, + -1, 291, 292, 293, -1, -1, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, -1, -1, -1, -1, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, -1, 329, + 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, + 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, -1, + -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, + -1, 391, 392, 393, 394, 395, -1, 397, 398, 399, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, -1, -1, 414, 415, -1, 417, 418, 419, + 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, + 430, 431, 432, 433, 434, -1, 436, 437, 438, 439, + 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, + 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, + 460, 461, -1, 463, 464, 465, 466, 467, 468, 469, + 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 3, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 514, -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, + -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, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, + 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 155, 156, 157, 158, -1, 160, -1, 162, 163, 164, + 165, -1, 167, -1, 169, -1, 171, -1, 173, 174, + 175, -1, 177, -1, 179, -1, 181, 182, 183, 184, + -1, 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 236, -1, 238, 239, 240, 241, 242, 243, 244, + 205, -1, 207, -1, 209, 210, 211, 212, 213, 214, + 215, 216, -1, 218, -1, 220, -1, -1, 223, -1, + 225, 226, 227, 228, 229, 230, -1, -1, 233, -1, + 235, -1, -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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 265, 266, 267, -1, 269, 270, 271, 272, 273, -1, + 275, 276, -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, + -1, 296, 297, 298, -1, 300, -1, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, + 355, 356, 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, + 375, 376, 377, 378, 379, -1, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, + 405, 406, 407, 408, 409, 410, 411, 412, -1, 414, + 415, 416, 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, + -1, 436, 437, 438, 439, 440, 441, 442, 443, -1, + -1, 446, 447, 448, 449, 450, 451, 452, 453, -1, + 455, 456, 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, + -1, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - 515, -1, -1, -1, 519, 520, 521, 522, 3, 4, - 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, + 495, 496, 497, 3, -1, 500, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 514, + -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, -1, + 160, -1, 162, 163, 164, 165, -1, 167, -1, 169, + -1, 171, -1, 173, 174, 175, -1, 177, -1, 179, + -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, + 190, 191, 192, -1, 194, 195, 196, 197, -1, 199, + 200, 201, 202, 203, 204, 205, -1, 207, -1, 209, + 210, 211, 212, 213, 214, 215, 216, -1, 218, -1, + 220, -1, -1, 223, -1, 225, 226, 227, 228, 229, + 230, -1, -1, 233, -1, 235, -1, -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, -1, 269, + 270, 271, 272, 273, -1, 275, 276, -1, 278, -1, + 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, + -1, 291, 292, 293, -1, -1, 296, 297, 298, -1, + 300, -1, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, -1, 318, 319, + 320, -1, 322, 323, 324, 325, 326, 327, -1, 329, + 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, + 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, + -1, -1, 392, 393, 394, 395, -1, 397, 398, 399, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, -1, -1, 414, 415, 416, 417, -1, 419, + 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, + 430, 431, 432, 433, 434, -1, 436, 437, 438, 439, + 440, 441, 442, 443, -1, -1, 446, 447, 448, 449, + 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, + 460, 461, -1, 463, -1, 465, 466, 467, 468, 469, + 470, 471, -1, -1, 474, -1, 476, 477, 478, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 3, -1, + 500, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 514, -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, + -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, -1, 120, 121, 122, 123, 124, + 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 155, 156, 157, 158, -1, 160, -1, 162, 163, 164, + 165, -1, 167, -1, 169, -1, 171, -1, 173, 174, + 175, -1, 177, -1, 179, -1, 181, 182, 183, 184, + -1, 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 236, -1, 238, 239, 240, 241, 242, 243, 244, + 205, -1, 207, -1, 209, 210, 211, 212, 213, 214, + 215, 216, -1, 218, -1, 220, -1, -1, 223, -1, + 225, 226, 227, 228, 229, 230, -1, -1, 233, -1, + 235, -1, -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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 265, 266, 267, -1, 269, 270, 271, 272, 273, -1, + 275, 276, -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, + -1, 296, 297, 298, -1, 300, -1, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, + 355, 356, 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, + 375, 376, 377, 378, 379, -1, 381, 382, 383, 384, + 385, 386, 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, 416, 417, 418, 419, 420, 421, 422, 423, -1, + 415, 416, 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, + -1, 436, 437, 438, 439, 440, 441, 442, 443, -1, + -1, 446, 447, 448, 449, 450, 451, 452, 453, -1, + 455, 456, 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, 473, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, + -1, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, 416, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, 416, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, -1, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, -1, -1, -1, -1, -1, -1, -1, - 505, 506, -1, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, -1, -1, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, -1, - 275, 276, -1, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, -1, -1, -1, -1, -1, -1, - 505, 506, 507, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, -1, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, -1, -1, -1, -1, -1, -1, -1, - 505, 506, -1, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, -1, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, -1, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, -1, -1, -1, -1, -1, -1, -1, - 505, 506, -1, -1, -1, -1, -1, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 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, -1, 162, 163, 164, - 165, -1, 167, -1, 169, 170, -1, 172, 173, 174, - 175, 176, 177, -1, 179, -1, 181, 182, 183, 184, - -1, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, - 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, -1, 218, -1, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, - 235, 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, 269, 270, 271, 272, 273, -1, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, - -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, - 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, - 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, -1, -1, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, -1, - 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, -1, - -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, - 455, 456, 457, 458, 459, 460, 461, -1, 463, 464, - 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, - -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, -1, -1, -1, -1, -1, -1, 3, - 4, 5, 6, 7, 8, 9, 10, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, 522, 22, 23, + 495, 496, 497, -1, 3, 500, 5, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 514, + -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, + -1, 160, -1, 162, 163, 164, 165, -1, 167, -1, + 169, -1, -1, -1, 173, 174, 175, -1, 177, -1, + 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, + 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, + 199, 200, 201, 202, 203, 204, 205, -1, 207, -1, + 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, + -1, 220, -1, -1, 223, -1, 225, 226, 227, 228, + 229, 230, -1, -1, 233, -1, 235, -1, -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, -1, + 269, 270, 271, 272, 273, -1, 275, 276, -1, 278, + -1, 280, 281, 282, 283, 284, 285, -1, 287, 288, + -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, + -1, 300, -1, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, + 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, + 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, + 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, -1, -1, 414, 415, -1, 417, -1, + 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, + -1, 430, 431, 432, 433, 434, -1, 436, 437, 438, + 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, + -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, + 459, 460, 461, -1, 463, -1, 465, 466, 467, 468, + 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 3, + -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 514, -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, + -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, -1, 120, 121, 122, 123, + 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, -1, 146, -1, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, -1, 162, 163, - 164, 165, -1, 167, -1, 169, 170, -1, 172, 173, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, -1, 160, -1, 162, 163, + 164, 165, -1, 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, - 204, 205, -1, 207, 208, 209, 210, 211, 212, 213, + 204, 205, -1, 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, 223, - 224, 225, 226, 227, 228, 229, 230, -1, -1, 233, - 234, 235, -1, -1, 238, 239, 240, 241, 242, 243, + -1, 225, 226, 227, 228, 229, 230, -1, -1, 233, + -1, 235, -1, -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, 269, 270, 271, 272, 273, - -1, 275, 276, -1, 278, 279, 280, 281, 282, 283, + 264, 265, 266, 267, -1, 269, 270, 271, 272, 273, + -1, 275, 276, -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, - -1, -1, 296, 297, 298, 299, 300, 301, 302, 303, + -1, -1, 296, 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - -1, -1, -1, -1, 318, 319, 320, 321, 322, 323, + -1, -1, -1, -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, -1, 359, 360, 361, 362, 363, + 354, 355, 356, 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, - 414, 415, -1, 417, 418, 419, 420, 421, 422, 423, + 414, 415, -1, 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, - 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 434, -1, 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, - 464, 465, 466, 467, 468, 469, 470, 471, -1, -1, + -1, 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, -1, -1, -1, -1, -1, -1, - -1, 505, 506, 507, -1, 3, 4, 5, 512, -1, - 514, 9, -1, -1, -1, 519, 520, 521, 522, -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, -1, 162, 163, 164, 165, -1, 167, - -1, 169, 170, -1, 172, 173, 174, 175, 176, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, -1, 275, 276, 277, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, 289, -1, 291, 292, 293, -1, -1, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, 435, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, 464, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - -1, -1, -1, -1, -1, -1, -1, 505, 506, 507, - -1, 3, 4, 5, 6, 7, 514, 9, -1, -1, - -1, -1, -1, -1, 522, -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, -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, -1, - 162, 163, 164, 165, -1, 167, -1, 169, 170, -1, - 172, 173, 174, 175, 176, 177, -1, 179, 180, 181, - 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, -1, 199, 200, 201, - 202, 203, 204, 205, -1, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, -1, 218, -1, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, -1, - -1, 233, 234, 235, 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, 269, 270, 271, - 272, 273, -1, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, - 292, 293, -1, -1, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, -1, -1, -1, -1, 318, 319, 320, 321, - 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, - 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, - 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, -1, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, - 382, 383, 384, 385, 386, 387, 388, 389, -1, 391, - 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - -1, -1, 414, 415, -1, 417, 418, 419, 420, 421, - 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, - 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, - -1, 463, 464, 465, 466, 467, 468, 469, 470, 471, - -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, -1, -1, -1, -1, - 3, 4, 5, 6, 7, -1, 9, -1, -1, -1, - 512, -1, 514, -1, -1, -1, -1, 519, 520, 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, -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, -1, 162, - 163, 164, 165, -1, 167, -1, 169, 170, -1, 172, - 173, 174, 175, 176, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, - 233, 234, 235, 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, 269, 270, 271, 272, - 273, -1, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, -1, -1, -1, -1, 3, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 512, - -1, 514, -1, -1, -1, -1, 519, 520, 22, 23, + 494, 495, 496, 497, 3, -1, 5, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 514, -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, + -1, 160, -1, 162, 163, 164, 165, -1, 167, -1, + 169, -1, -1, -1, 173, 174, 175, -1, 177, -1, + 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, + 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, + 199, 200, 201, 202, 203, 204, 205, -1, 207, -1, + 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, + -1, 220, -1, -1, 223, -1, 225, 226, 227, 228, + 229, 230, -1, -1, 233, -1, 235, -1, -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, -1, + 269, 270, 271, 272, 273, -1, 275, 276, -1, 278, + -1, 280, 281, 282, 283, 284, 285, -1, 287, 288, + -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, + -1, 300, -1, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, + 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, + 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, + 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, -1, -1, 414, 415, -1, 417, -1, + 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, + -1, 430, 431, 432, 433, 434, -1, 436, 437, 438, + 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, + -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, + 459, 460, 461, -1, 463, -1, 465, 466, 467, 468, + 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 3, + -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 514, -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, @@ -399724,22 +405121,22 @@ static const yytype_int16 yycheck[] = 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, -1, 160, 161, 162, 163, - 164, 165, 166, 167, -1, 169, -1, -1, -1, 173, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, -1, 160, -1, 162, 163, + 164, 165, -1, 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, -1, 220, -1, -1, 223, + 214, 215, 216, -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, 233, - -1, 235, -1, 237, 238, 239, 240, 241, 242, 243, + -1, 235, -1, -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, 283, - 284, 285, 286, 287, 288, -1, -1, 291, 292, 293, - -1, 295, 296, 297, 298, -1, 300, -1, 302, 303, + 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, + -1, -1, 296, 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, @@ -399754,14 +405151,113 @@ static const yytype_int16 yycheck[] = 414, 415, -1, 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, 443, - 444, -1, 446, 447, 448, -1, 450, 451, 452, 453, + -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 515, -1, 22, 23, 24, 25, 26, 27, 28, + 514, -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, + -1, 160, -1, 162, 163, 164, 165, -1, 167, -1, + 169, -1, -1, -1, 173, 174, 175, -1, 177, -1, + 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, + 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, + 199, 200, 201, 202, 203, 204, 205, -1, 207, -1, + 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, + -1, 220, -1, -1, 223, -1, 225, 226, 227, 228, + 229, 230, -1, -1, 233, -1, 235, -1, -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, -1, + 269, 270, 271, 272, 273, -1, 275, 276, -1, 278, + -1, 280, 281, 282, 283, 284, 285, -1, 287, 288, + -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, + -1, 300, -1, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, + 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, + 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, + 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, -1, -1, 414, 415, -1, 417, -1, + 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, + -1, 430, 431, 432, 433, 434, -1, 436, 437, 438, + 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, + -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, + 459, 460, 461, -1, 463, -1, 465, 466, 467, 468, + 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 3, + -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 514, -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, -1, 160, -1, 162, 163, + 164, 165, -1, 167, -1, 169, -1, -1, -1, 173, + 174, 175, -1, 177, -1, 179, -1, 181, 182, 183, + 184, -1, 186, 187, 188, 189, 190, 191, 192, -1, + 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, + 204, 205, -1, 207, -1, 209, 210, 211, 212, 213, + 214, 215, 216, -1, 218, -1, 220, -1, -1, 223, + -1, 225, 226, 227, 228, 229, 230, -1, -1, 233, + -1, 235, -1, -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, -1, 269, 270, 271, 272, 273, + -1, 275, 276, -1, 278, -1, 280, 281, 282, 283, + 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, + -1, -1, 296, 297, 298, -1, 300, -1, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + -1, -1, -1, -1, 318, 319, 320, -1, 322, 323, + 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, + 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, + -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, -1, 359, 360, -1, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, -1, -1, 381, 382, 383, + 384, 385, 386, 387, 388, 389, -1, -1, 392, 393, + 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, + 414, 415, -1, 417, -1, 419, 420, 421, 422, 423, + -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, + 434, -1, 436, 437, 438, 439, 440, 441, 442, 443, + -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, + -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, + -1, 465, 466, 467, 468, 469, 470, 471, -1, -1, + 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 3, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 514, -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, @@ -399810,111 +405306,1073 @@ static const yytype_int16 yycheck[] = 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 514, 515, -1, 22, 23, + -1, -1, -1, -1, -1, 514, -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, 61, 62, 63, + -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, 103, + -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, + 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, -1, 160, -1, 162, 163, - 164, 165, -1, 167, -1, 169, 170, 171, 172, 173, - 174, 175, 176, 177, -1, 179, -1, 181, 182, 183, - 184, -1, 186, 187, 188, 189, 190, 191, 192, 193, + 164, 165, -1, 167, -1, 169, -1, -1, -1, 173, + 174, 175, -1, 177, -1, 179, -1, 181, 182, 183, + 184, -1, 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, - 204, 205, -1, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, -1, 218, -1, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, -1, -1, 233, - 234, 235, 236, -1, 238, 239, 240, 241, 242, 243, + 204, 205, -1, 207, -1, 209, 210, 211, 212, 213, + 214, 215, 216, -1, 218, -1, 220, -1, -1, 223, + -1, 225, 226, 227, 228, 229, 230, -1, -1, 233, + -1, 235, -1, -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, 269, 270, 271, 272, 273, - -1, 275, 276, 277, 278, -1, 280, 281, 282, 283, + 264, 265, 266, 267, -1, 269, 270, 271, 272, 273, + -1, 275, 276, -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, - -1, -1, 296, 297, 298, 299, 300, 301, 302, 303, + -1, -1, 296, 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, -1, 318, 319, 320, 321, 322, 323, + -1, -1, -1, -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, -1, 359, 360, 361, 362, 363, + 354, 355, 356, 357, -1, 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, + 374, 375, 376, 377, 378, -1, -1, 381, 382, 383, + 384, 385, 386, 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, -1, - 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, + 404, 405, 406, 407, 408, 409, 410, 411, -1, -1, + 414, 415, -1, 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, 443, - -1, -1, 446, 447, 448, 449, 450, 451, 452, 453, + -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, - 464, 465, 466, 467, 468, 469, 470, 471, -1, -1, - 474, -1, 476, 477, 478, 479, 480, 481, 482, 483, + -1, 465, 466, 467, 468, 469, 470, 471, -1, -1, + 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, -1, 3, 500, 5, -1, -1, + 494, 495, 496, 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 514, -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, + 514, -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, + -1, 160, -1, 162, 163, 164, 165, -1, 167, -1, + 169, -1, -1, -1, 173, 174, 175, -1, 177, -1, + 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, + 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, + 199, 200, 201, 202, 203, 204, 205, -1, 207, -1, + 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, + -1, 220, -1, -1, 223, -1, 225, 226, 227, 228, + 229, 230, -1, -1, 233, -1, 235, -1, -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, -1, + 269, 270, 271, 272, 273, -1, 275, 276, -1, 278, + -1, 280, 281, 282, 283, 284, 285, -1, 287, 288, + -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, + -1, 300, -1, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, + 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, + 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, + 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, -1, -1, 414, 415, -1, 417, -1, + 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, + -1, 430, 431, 432, 433, 434, -1, 436, 437, 438, + 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, + -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, + 459, 460, 461, -1, 463, -1, 465, 466, 467, 468, + 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, -1, + 3, 4, 5, -1, -1, 8, 9, -1, -1, -1, + -1, -1, 15, 16, -1, 514, 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, -1, 159, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, -1, -1, + 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, -1, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, -1, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, -1, 299, 300, 301, -1, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, -1, 321, 322, + 323, -1, 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, -1, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 430, 431, -1, + 433, -1, 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, -1, 461, 462, + 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, + 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 494, 495, 496, 497, -1, 3, -1, 501, 502, + 503, 8, 505, 506, 507, 508, 509, 510, 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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, -1, -1, -1, 501, 502, 503, -1, 505, 506, + 507, 508, 509, 510, 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, 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, -1, -1, -1, -1, -1, -1, 46, 8, -1, + -1, 11, 176, -1, 53, 15, 16, 17, 18, 19, + 20, 21, -1, -1, -1, -1, -1, -1, -1, 193, + -1, -1, -1, -1, 198, -1, 36, -1, -1, -1, + -1, 80, -1, -1, -1, -1, 46, -1, -1, -1, + -1, 176, -1, 53, -1, -1, -1, 221, 222, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 193, -1, + -1, -1, 236, 198, -1, -1, -1, -1, -1, -1, + 80, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 176, -1, -1, -1, -1, -1, 221, 222, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 193, -1, -1, + 274, 236, 198, 277, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 291, -1, -1, + 294, -1, -1, -1, -1, 221, 222, 176, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 274, + 236, -1, 277, -1, 193, -1, -1, -1, -1, 198, + -1, -1, -1, -1, -1, -1, 291, -1, -1, 294, + -1, -1, -1, -1, -1, -1, 176, -1, -1, -1, + -1, -1, 221, 222, -1, -1, -1, -1, 274, -1, + -1, 277, -1, 193, -1, -1, -1, 236, 198, -1, + -1, -1, -1, -1, -1, 291, -1, -1, 294, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 221, 222, -1, -1, -1, -1, 391, -1, -1, + -1, -1, -1, -1, -1, 274, 236, -1, 277, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 291, -1, -1, 294, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 391, -1, -1, -1, + -1, -1, -1, -1, 274, -1, -1, 277, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 291, -1, -1, 294, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 391, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 498, -1, -1, 501, 502, 503, + -1, 505, 506, 507, 508, 509, 510, -1, -1, -1, + -1, 515, 391, -1, -1, -1, -1, -1, 8, -1, + -1, 11, -1, -1, -1, 15, 16, 17, 18, 19, + 20, 21, -1, 498, -1, -1, 501, 502, 503, -1, + 505, 506, 507, 508, 509, 510, 36, -1, -1, -1, + 515, 391, -1, -1, -1, -1, 46, -1, -1, -1, + -1, -1, -1, 53, -1, -1, -1, -1, -1, -1, + -1, -1, 498, -1, -1, 501, 502, 503, -1, 505, + 506, 507, 508, 509, 510, -1, -1, -1, -1, 515, + 80, -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, 498, + -1, -1, 501, 502, 503, -1, 505, 506, 507, 508, + 509, 510, 36, -1, -1, -1, 515, -1, -1, -1, + -1, -1, 46, 8, -1, -1, 11, -1, -1, 53, + 15, 16, 17, 18, 19, 20, 21, -1, 498, -1, + -1, 501, 502, 503, -1, 505, 506, 507, 508, 509, + 510, 36, -1, -1, -1, 515, 80, -1, -1, -1, + -1, 46, 8, -1, -1, 11, 176, -1, 53, 15, + 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, + -1, -1, -1, 193, -1, -1, -1, -1, 198, -1, + 36, -1, -1, -1, -1, 80, -1, -1, -1, -1, + 46, -1, -1, -1, -1, -1, -1, 53, -1, -1, + -1, 221, 222, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 236, -1, -1, -1, + -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 8, -1, + -1, 11, 176, -1, -1, 15, 16, 17, 18, 19, + 20, 21, -1, -1, 274, -1, -1, 277, -1, 193, + -1, -1, -1, -1, 198, -1, 36, -1, -1, -1, + -1, 291, -1, -1, 294, -1, 46, -1, -1, -1, + -1, 176, -1, 53, -1, -1, -1, 221, 222, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 193, -1, + -1, -1, 236, 198, -1, -1, -1, -1, -1, -1, + 80, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 176, -1, -1, -1, -1, -1, 221, 222, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 193, -1, -1, + 274, 236, 198, 277, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 291, -1, -1, + 294, -1, -1, -1, -1, 221, 222, -1, -1, -1, + -1, 391, -1, -1, -1, -1, -1, -1, -1, 274, + 236, -1, 277, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 291, -1, -1, 294, + -1, -1, -1, -1, -1, -1, 176, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 274, -1, + -1, 277, -1, 193, -1, -1, -1, -1, 198, -1, + -1, -1, -1, -1, -1, 291, -1, -1, 294, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 221, 222, -1, -1, -1, -1, 391, -1, -1, + -1, -1, -1, -1, -1, -1, 236, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 498, -1, + -1, 501, 502, 503, -1, 505, 506, 507, 508, 509, + 510, -1, -1, -1, -1, 515, 391, -1, -1, -1, + -1, -1, -1, -1, 274, -1, 8, 277, -1, 11, + -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, + -1, 291, -1, -1, 294, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 36, 391, 24, -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, -1, 498, -1, -1, 501, 502, 503, + -1, 505, 506, 507, 508, 509, 510, -1, 80, -1, + -1, 515, -1, -1, -1, -1, -1, -1, 8, -1, + -1, 11, -1, 81, -1, 15, 16, 17, 18, 19, + 20, 21, -1, 498, -1, -1, 501, 502, 503, 97, + 505, 506, 507, 508, 509, 510, 36, -1, -1, -1, + 515, 391, -1, -1, -1, -1, 46, -1, -1, -1, + -1, -1, -1, 53, -1, -1, -1, -1, -1, -1, + -1, -1, 498, -1, -1, 501, 502, 503, -1, 505, + 506, 507, 508, 509, 510, -1, -1, 513, 146, -1, + 80, -1, -1, -1, -1, -1, -1, -1, 156, -1, + -1, -1, -1, -1, 176, -1, -1, -1, -1, -1, + 168, -1, -1, -1, -1, 173, -1, -1, -1, -1, + -1, 193, -1, -1, -1, -1, 198, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 202, -1, -1, -1, -1, 221, + 222, -1, -1, -1, -1, -1, -1, -1, 498, -1, + -1, 501, 502, 503, 236, 505, 506, 507, 508, 509, + 510, -1, -1, 513, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 176, 245, -1, -1, + -1, 249, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 274, 193, -1, 277, -1, -1, 198, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 291, + -1, -1, 294, -1, -1, -1, -1, -1, -1, -1, + -1, 221, 222, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 236, -1, -1, -1, + -1, -1, -1, -1, -1, 313, -1, -1, -1, -1, + -1, 319, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 334, -1, -1, -1, + -1, -1, -1, -1, 274, -1, -1, 277, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 291, -1, -1, 294, -1, -1, -1, -1, 367, + -1, -1, 370, -1, -1, -1, -1, -1, -1, 391, + -1, -1, -1, 381, -1, -1, 384, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 402, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 416, -1, + -1, -1, -1, -1, 422, 423, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 433, -1, -1, -1, -1, + -1, 439, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 391, -1, -1, -1, -1, -1, -1, 466, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 498, -1, -1, 501, + 502, 503, -1, 505, 506, 507, 508, 509, 510, -1, + -1, 513, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -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, 498, -1, + -1, 501, 502, 503, -1, 505, 506, 507, 508, 509, + 510, -1, -1, 513, 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, - -1, 59, 60, 61, 62, 63, 64, -1, 66, 67, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, + 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, + 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, + 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, + 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 3, -1, -1, -1, -1, -1, -1, -1, -1, 507, + -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, -1, 160, -1, 162, + 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, + 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, + 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, + -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, + 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, + 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, + 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, + 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, + 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, + 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, + 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, + 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, + 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, + 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, + 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, + 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, + 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, + -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, + 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, + 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, + 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, + 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, + 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, + -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 3, -1, -1, -1, -1, + -1, -1, -1, -1, 507, -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, 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, + 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, + 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, 170, 171, 172, 173, 174, 175, 176, 177, + -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, -1, 233, 234, 235, 236, -1, + -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, + 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, + 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, 269, 270, 271, 272, 273, -1, 275, 276, 277, + -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, 290, 291, 292, 293, -1, -1, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, -1, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, + 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, + 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, + -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, -1, 397, + 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, + 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, -1, 414, 415, 416, 417, - 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, + 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, + -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, 449, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, 464, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, 476, 477, + 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, + 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, + 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - -1, 3, 500, 5, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 514, -1, -1, -1, + 3, 4, 5, -1, -1, -1, 9, -1, -1, 507, + -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, -1, 162, + 163, 164, 165, -1, 167, -1, 169, 170, -1, 172, + 173, 174, 175, 176, 177, -1, 179, -1, 181, 182, + 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, + 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, + 233, 234, 235, 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, 269, 270, 271, 272, + 273, -1, 275, 276, 277, 278, -1, 280, 281, 282, + 283, 284, 285, -1, 287, 288, 289, -1, 291, 292, + 293, -1, -1, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, -1, -1, -1, -1, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, + 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, + 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, + 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, -1, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, + 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, + -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, + 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, + 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, + 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, + 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, + -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 494, 495, 496, 497, -1, -1, 8, -1, -1, + 11, -1, 505, 506, 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, -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, 40, -1, -1, -1, -1, + -1, 46, -1, 8, -1, 176, 11, -1, 53, -1, + 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, + -1, -1, 193, -1, -1, -1, -1, 198, -1, -1, + -1, 36, -1, -1, 166, 80, -1, -1, -1, 171, + -1, 46, -1, -1, 176, -1, -1, -1, 53, -1, + 221, 222, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 193, -1, -1, -1, 236, 198, -1, -1, -1, + -1, -1, 165, -1, -1, 80, -1, -1, -1, -1, + -1, -1, -1, 176, -1, -1, -1, -1, -1, 221, + 222, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 193, -1, -1, 274, 236, 198, 277, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 291, -1, -1, 294, -1, -1, -1, -1, 221, 222, + -1, 176, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 274, 236, -1, 277, -1, -1, 193, -1, + -1, -1, -1, 198, -1, -1, -1, -1, -1, 291, + -1, -1, 294, -1, -1, -1, -1, -1, -1, -1, + -1, 176, -1, -1, -1, -1, 221, 222, -1, -1, + -1, 274, -1, -1, 277, -1, -1, -1, 193, -1, + -1, 236, -1, 198, -1, -1, -1, -1, 291, -1, + -1, 294, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 221, 222, -1, -1, + 391, -1, -1, -1, -1, -1, -1, -1, -1, 274, + 323, 236, 277, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 291, -1, -1, 294, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 391, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 274, + -1, -1, 277, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 454, -1, -1, 291, -1, -1, 294, + -1, -1, -1, -1, -1, -1, -1, -1, 391, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 317, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 498, -1, -1, + 501, 502, 503, -1, 505, 506, 507, 508, 509, 510, + -1, -1, -1, -1, -1, -1, 391, -1, -1, -1, + -1, 8, -1, -1, 11, -1, -1, -1, 15, 16, + 17, 18, 19, 20, 21, -1, 498, -1, -1, 501, + 502, 503, -1, 505, 506, 507, 508, 509, 510, 36, + -1, -1, -1, 40, -1, -1, 391, -1, -1, 46, + -1, -1, -1, -1, -1, -1, 53, -1, -1, -1, + -1, -1, -1, -1, -1, 498, -1, -1, 501, 502, + 503, -1, 505, 506, 507, 508, 509, 510, -1, -1, + -1, -1, -1, 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, 498, -1, -1, 501, 502, 503, -1, + 505, 506, 507, 508, 509, 510, 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, 498, -1, -1, 501, 502, 503, -1, + 505, 506, 507, 508, 509, 510, -1, -1, -1, -1, + 80, -1, -1, -1, -1, 8, -1, -1, 11, 176, + -1, -1, 15, 16, 17, 18, 19, 20, 21, -1, + -1, -1, -1, -1, -1, -1, 193, -1, -1, -1, + -1, 198, -1, 36, -1, -1, -1, 40, -1, -1, + -1, -1, -1, 46, -1, -1, -1, -1, -1, -1, + 53, -1, -1, -1, 221, 222, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 236, + -1, -1, -1, -1, -1, -1, -1, 80, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 171, 8, -1, -1, 11, 176, -1, -1, 15, + 16, 17, 18, 19, 20, 21, -1, 274, -1, -1, + 277, -1, -1, 193, -1, -1, -1, -1, 198, -1, + 36, -1, -1, -1, 291, -1, -1, 294, -1, -1, + 46, -1, -1, -1, -1, -1, -1, 53, -1, -1, + -1, 221, 222, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 236, -1, -1, -1, + -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, + -1, -1, -1, 176, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 193, -1, -1, -1, 274, 198, -1, 277, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 291, -1, -1, 294, -1, -1, -1, 221, 222, + -1, -1, -1, -1, 391, -1, -1, 8, -1, -1, + 11, -1, -1, 236, 15, 16, 17, 18, 19, 20, + 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 166, -1, -1, -1, -1, 36, -1, -1, -1, -1, + 176, -1, -1, -1, -1, 46, -1, -1, -1, -1, + -1, 274, 53, -1, 277, -1, -1, 193, -1, -1, + -1, -1, 198, -1, -1, -1, -1, -1, 291, -1, + -1, 294, -1, -1, -1, -1, -1, -1, -1, 80, + -1, -1, -1, -1, -1, 221, 222, -1, -1, -1, + -1, 391, -1, -1, -1, -1, -1, -1, -1, -1, + 236, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 498, -1, -1, 501, 502, 503, -1, 505, 506, + 507, 508, 509, 510, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 274, -1, + -1, 277, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 291, -1, -1, 294, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 391, -1, + -1, -1, -1, -1, -1, 176, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 193, -1, -1, -1, -1, 198, 498, -1, + -1, 501, 502, 503, -1, 505, 506, 507, 508, 509, + 510, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 221, 222, -1, -1, -1, -1, -1, -1, -1, 8, + -1, -1, 11, -1, -1, 236, 15, 16, 17, 18, + 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 391, -1, 36, -1, -1, + -1, 40, -1, -1, -1, -1, -1, 46, -1, -1, + -1, -1, -1, 274, 53, 498, 277, -1, 501, 502, + 503, -1, 505, 506, 507, 508, 509, 510, -1, -1, + 291, -1, -1, 294, -1, -1, -1, -1, -1, -1, + -1, 80, -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, -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, + -1, -1, 498, -1, -1, 501, 502, 503, -1, 505, + 506, 507, 508, 509, 510, 80, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 391, -1, 8, -1, -1, 11, -1, 176, -1, 15, + 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, + -1, -1, -1, -1, 193, -1, -1, -1, -1, 198, + 36, -1, -1, 424, -1, -1, -1, -1, -1, -1, + 46, -1, -1, -1, -1, -1, -1, 53, -1, -1, + -1, -1, 221, 222, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 236, -1, -1, + -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, + -1, 176, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 193, -1, + -1, -1, -1, 198, -1, 274, -1, 498, 277, -1, + 501, 502, 503, -1, 505, 506, 507, 508, 509, 510, + -1, -1, 291, -1, -1, 294, 221, 222, -1, -1, + -1, -1, -1, -1, -1, 8, -1, -1, 11, -1, + -1, 236, 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, + 176, -1, -1, 46, -1, -1, -1, -1, -1, 274, + 53, -1, 277, -1, -1, -1, -1, 193, -1, -1, + -1, -1, 198, -1, -1, -1, 291, -1, -1, 294, + -1, -1, -1, -1, -1, -1, 8, 80, -1, 11, + -1, -1, -1, 15, 16, 221, 222, 19, 20, 21, + -1, -1, 391, -1, -1, -1, -1, -1, -1, -1, + 236, -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, -1, -1, -1, -1, -1, 274, -1, + -1, 277, -1, -1, -1, -1, -1, -1, 80, -1, + -1, -1, -1, -1, -1, 291, -1, -1, 294, -1, + -1, -1, -1, -1, -1, -1, 391, 8, -1, -1, + 11, -1, -1, 176, 15, 16, -1, -1, 19, 20, + 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 193, -1, -1, -1, -1, 198, -1, -1, -1, 498, + -1, -1, 501, 502, 503, 46, 505, 506, 507, 508, + 509, 510, 53, -1, -1, -1, -1, -1, 221, 222, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 236, -1, -1, -1, -1, -1, 80, + -1, -1, -1, -1, 176, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 391, -1, -1, -1, -1, + -1, 193, -1, -1, -1, -1, 198, -1, -1, -1, + -1, 274, -1, 498, 277, -1, 501, 502, 503, -1, + 505, 506, 507, 508, 509, 510, -1, -1, 291, 221, + 222, 294, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 236, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 176, -1, -1, -1, -1, + -1, -1, 274, -1, -1, 277, -1, -1, -1, -1, + -1, -1, 193, -1, -1, -1, -1, 198, -1, 291, + -1, -1, 498, -1, -1, 501, 502, 503, -1, 505, + 506, 507, 508, 509, 510, -1, -1, -1, -1, -1, + 221, 222, -1, -1, -1, -1, -1, -1, 391, -1, + -1, -1, -1, -1, -1, 236, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 277, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 291, -1, -1, -1, -1, -1, -1, -1, -1, 391, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 498, -1, -1, 501, 502, + 503, -1, 505, 506, 507, 508, 509, 510, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 391, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 498, -1, -1, 501, + 502, 503, -1, 505, 506, 507, 508, 509, 510, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -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, 498, -1, -1, + 501, 502, 503, -1, 505, 506, 507, 508, 509, 510, + 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, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, + 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, + 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, + 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, + 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 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, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, + 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, + 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, + 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, + 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 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, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, + 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, + 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, + 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, -1, 162, 163, 164, 165, -1, + 167, -1, 169, 170, -1, 172, 173, 174, 175, 176, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, -1, 275, 276, + 277, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, 289, -1, 291, 292, 293, -1, -1, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, 380, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, 391, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, 464, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 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, + 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, 66, 67, 68, 69, 70, 71, + 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, @@ -399930,13 +406388,13 @@ static const yytype_int16 yycheck[] = 192, 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 222, 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, -1, 280, 281, - 282, 283, 284, 285, -1, 287, 288, -1, 290, 291, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, 321, @@ -399945,7 +406403,7 @@ static const yytype_int16 yycheck[] = 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 372, 373, 374, 375, 376, 377, 378, -1, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, @@ -399959,7 +406417,7 @@ static const yytype_int16 yycheck[] = 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 514, -1, -1, 22, 23, 24, 25, 26, + -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, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, @@ -400008,12 +406466,12 @@ static const yytype_int16 yycheck[] = 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 514, -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, 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, + 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, @@ -400058,22 +406516,121 @@ static const yytype_int16 yycheck[] = 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 514, -1, -1, 22, 23, 24, 25, 26, + -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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, 168, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, 328, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, 445, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 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, 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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, 168, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, 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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, 445, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, 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, + -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, -1, 160, -1, 162, 163, 164, 165, -1, - 167, -1, 169, -1, 171, -1, 173, 174, 175, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, @@ -400087,27 +406644,27 @@ static const yytype_int16 yycheck[] = -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, -1, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 390, -1, 392, 393, 394, 395, -1, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, -1, 414, 415, 416, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, - 447, 448, 449, 450, 451, 452, 453, -1, 455, 456, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, - 467, 468, 469, 470, 471, -1, -1, 474, -1, 476, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 3, -1, 500, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 514, -1, -1, + 497, 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, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, @@ -400122,7 +406679,7 @@ static const yytype_int16 yycheck[] = -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, -1, 160, -1, - 162, 163, 164, 165, -1, 167, -1, 169, -1, 171, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, @@ -400137,27 +406694,27 @@ static const yytype_int16 yycheck[] = 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, -1, 318, 319, 320, -1, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, -1, 381, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - -1, -1, 414, 415, 416, 417, -1, 419, 420, 421, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, - 442, 443, -1, -1, 446, 447, 448, 449, 450, 451, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, - -1, -1, 474, -1, 476, 477, 478, 479, 480, 481, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 3, -1, 500, -1, + 492, 493, 494, 495, 496, 497, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 514, -1, -1, 22, 23, 24, 25, 26, + -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, @@ -400172,7 +406729,7 @@ static const yytype_int16 yycheck[] = 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, -1, 160, -1, 162, 163, 164, 165, -1, - 167, -1, 169, -1, 171, -1, 173, 174, 175, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, @@ -400184,3840 +406741,2019 @@ static const yytype_int16 yycheck[] = 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, - 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 287, 288, -1, 290, 291, 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, -1, 381, 382, 383, 384, 385, 386, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, -1, -1, 414, 415, 416, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, - 447, 448, 449, 450, 451, 452, 453, -1, 455, 456, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, - 467, 468, 469, 470, 471, -1, -1, 474, -1, 476, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, -1, 3, 500, 5, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 514, -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, -1, 160, - -1, 162, 163, 164, 165, -1, 167, -1, 169, -1, - -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, - 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, - 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, - 201, 202, 203, 204, 205, -1, 207, -1, 209, 210, - 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, - -1, -1, 223, -1, 225, 226, 227, 228, 229, 230, - -1, -1, 233, -1, 235, -1, -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, -1, 269, 270, - 271, 272, 273, -1, 275, 276, -1, 278, -1, 280, - 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, - 291, 292, 293, -1, -1, 296, 297, 298, -1, 300, - -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, - -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, - 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, - 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, -1, -1, - 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, - -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, -1, -1, 414, 415, -1, 417, -1, 419, 420, - 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, - 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, - 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, - 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, - 461, -1, 463, -1, 465, 466, 467, 468, 469, 470, - 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 3, -1, 5, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 514, -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, -1, 160, -1, 162, 163, 164, 165, - -1, 167, -1, 169, -1, -1, -1, 173, 174, 175, - -1, 177, -1, 179, -1, 181, 182, 183, 184, -1, - 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, - 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, - -1, 207, -1, 209, 210, 211, 212, 213, 214, 215, - 216, -1, 218, -1, 220, -1, -1, 223, -1, 225, - 226, 227, 228, 229, 230, -1, -1, 233, -1, 235, - -1, -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, -1, 269, 270, 271, 272, 273, -1, 275, - 276, -1, 278, -1, 280, 281, 282, 283, 284, 285, - -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, - 296, 297, 298, -1, 300, -1, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, -1, -1, - -1, -1, 318, 319, 320, -1, 322, 323, 324, 325, - 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, - 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, - 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, -1, 359, 360, -1, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, - 386, 387, 388, 389, -1, -1, 392, 393, 394, 395, - -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, - -1, 417, -1, 419, 420, 421, 422, 423, -1, 425, - 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, - 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, - 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, - 456, 457, 458, 459, 460, 461, -1, 463, -1, 465, - 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, - -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 3, -1, 5, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 514, -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, -1, 160, - -1, 162, 163, 164, 165, -1, 167, -1, 169, -1, - -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, - 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, - 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, - 201, 202, 203, 204, 205, -1, 207, -1, 209, 210, - 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, - -1, -1, 223, -1, 225, 226, 227, 228, 229, 230, - -1, -1, 233, -1, 235, -1, -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, -1, 269, 270, - 271, 272, 273, -1, 275, 276, -1, 278, -1, 280, - 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, - 291, 292, 293, -1, -1, 296, 297, 298, -1, 300, - -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, - -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, - 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, - 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, -1, -1, - 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, - -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, -1, -1, 414, 415, -1, 417, -1, 419, 420, - 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, - 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, - 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, - 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, - 461, -1, 463, -1, 465, 466, 467, 468, 469, 470, - 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 3, -1, 5, + 497, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 514, -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, -1, 160, -1, 162, 163, 164, 165, - -1, 167, -1, 169, -1, -1, -1, 173, 174, 175, - -1, 177, -1, 179, -1, 181, 182, 183, 184, -1, - 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, - 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, - -1, 207, -1, 209, 210, 211, 212, 213, 214, 215, - 216, -1, 218, -1, 220, -1, -1, 223, -1, 225, - 226, 227, 228, 229, 230, -1, -1, 233, -1, 235, - -1, -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, -1, 269, 270, 271, 272, 273, -1, 275, - 276, -1, 278, -1, 280, 281, 282, 283, 284, 285, - -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, - 296, 297, 298, -1, 300, -1, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, -1, -1, - -1, -1, 318, 319, 320, -1, 322, 323, 324, 325, - 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, - 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, - 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, -1, 359, 360, -1, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, - 386, 387, 388, 389, -1, -1, 392, 393, 394, 395, - -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, - -1, 417, -1, 419, 420, 421, 422, 423, -1, 425, - 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, - 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, - 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, - 456, 457, 458, 459, 460, 461, -1, 463, -1, 465, - 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, - -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 3, -1, 5, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 514, -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, -1, 160, - -1, 162, 163, 164, 165, -1, 167, -1, 169, -1, - -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, - 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, - 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, - 201, 202, 203, 204, 205, -1, 207, -1, 209, 210, - 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, - -1, -1, 223, -1, 225, 226, 227, 228, 229, 230, - -1, -1, 233, -1, 235, -1, -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, -1, 269, 270, - 271, 272, 273, -1, 275, 276, -1, 278, -1, 280, - 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, - 291, 292, 293, -1, -1, 296, 297, 298, -1, 300, - -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, - -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, - 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, - 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, -1, -1, - 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, - -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, -1, -1, 414, 415, -1, 417, -1, 419, 420, - 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, - 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, - 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, - 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, - 461, -1, 463, -1, 465, 466, 467, 468, 469, 470, - 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 3, -1, 5, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 514, -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, -1, 160, -1, 162, 163, 164, 165, - -1, 167, -1, 169, -1, -1, -1, 173, 174, 175, - -1, 177, -1, 179, -1, 181, 182, 183, 184, -1, - 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, - 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, - -1, 207, -1, 209, 210, 211, 212, 213, 214, 215, - 216, -1, 218, -1, 220, -1, -1, 223, -1, 225, - 226, 227, 228, 229, 230, -1, -1, 233, -1, 235, - -1, -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, -1, 269, 270, 271, 272, 273, -1, 275, - 276, -1, 278, -1, 280, 281, 282, 283, 284, 285, - -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, - 296, 297, 298, -1, 300, -1, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, -1, -1, - -1, -1, 318, 319, 320, -1, 322, 323, 324, 325, - 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, - 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, - 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, -1, 359, 360, -1, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, - 386, 387, 388, 389, -1, -1, 392, 393, 394, 395, - -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, - -1, 417, -1, 419, 420, 421, 422, 423, -1, 425, - 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, - 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, - 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, - 456, 457, 458, 459, 460, 461, -1, 463, -1, 465, - 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, - -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 3, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 514, -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, -1, 160, - -1, 162, 163, 164, 165, -1, 167, -1, 169, -1, - -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, - 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, - 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, - 201, 202, 203, 204, 205, -1, 207, -1, 209, 210, - 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, - -1, -1, 223, -1, 225, 226, 227, 228, 229, 230, - -1, -1, 233, -1, 235, -1, -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, -1, 269, 270, - 271, 272, 273, -1, 275, 276, -1, 278, -1, 280, - 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, - 291, 292, 293, -1, -1, 296, 297, 298, -1, 300, - -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, - -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, - 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, - 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, -1, -1, - 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, - -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, -1, -1, 414, 415, -1, 417, -1, 419, 420, - 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, - 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, - 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, - 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, - 461, -1, 463, -1, 465, 466, 467, 468, 469, 470, - 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 3, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 514, -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, -1, 160, -1, 162, 163, 164, 165, - -1, 167, -1, 169, -1, -1, -1, 173, 174, 175, - -1, 177, -1, 179, -1, 181, 182, 183, 184, -1, - 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, - 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, - -1, 207, -1, 209, 210, 211, 212, 213, 214, 215, - 216, -1, 218, -1, 220, -1, -1, 223, -1, 225, - 226, 227, 228, 229, 230, -1, -1, 233, -1, 235, - -1, -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, -1, 269, 270, 271, 272, 273, -1, 275, - 276, -1, 278, -1, 280, 281, 282, 283, 284, 285, - -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, - 296, 297, 298, -1, 300, -1, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, -1, -1, - -1, -1, 318, 319, 320, -1, 322, 323, 324, 325, - 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, - 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, - 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, -1, 359, 360, -1, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, - 386, 387, 388, 389, -1, -1, 392, 393, 394, 395, - -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, - -1, 417, -1, 419, 420, 421, 422, 423, -1, 425, - 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, - 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, - 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, - 456, 457, 458, 459, 460, 461, -1, 463, -1, 465, - 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, - -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 3, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 514, -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, -1, 160, - -1, 162, 163, 164, 165, -1, 167, -1, 169, -1, - -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, - 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, - 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, - 201, 202, 203, 204, 205, -1, 207, -1, 209, 210, - 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, - -1, -1, 223, -1, 225, 226, 227, 228, 229, 230, - -1, -1, 233, -1, 235, -1, -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, -1, 269, 270, - 271, 272, 273, -1, 275, 276, -1, 278, -1, 280, - 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, - 291, 292, 293, -1, -1, 296, 297, 298, -1, 300, - -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, - -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, - 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, - 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, -1, -1, - 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, - -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, -1, -1, 414, 415, -1, 417, -1, 419, 420, - 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, - 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, - 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, - 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, - 461, -1, 463, -1, 465, 466, 467, 468, 469, 470, - 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, -1, 3, 4, - 5, -1, -1, 8, 9, -1, -1, -1, -1, -1, - 15, 16, -1, 514, 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, -1, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, -1, -1, 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, -1, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, -1, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, -1, 299, 300, 301, -1, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, -1, 321, 322, 323, -1, - 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, -1, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 427, 428, 429, 430, 431, -1, 433, -1, - 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, -1, 461, 462, 463, 464, - 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, - 475, 476, 477, 478, 479, 480, 481, 482, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 494, - 495, 496, 497, -1, 3, -1, 501, 502, 503, 8, - 505, 506, 507, 508, 509, 510, 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, - -1, 160, -1, 162, 163, 164, 165, -1, 167, -1, - 169, -1, -1, -1, 173, 174, 175, -1, 177, -1, - 179, -1, 181, 182, 183, 184, -1, 186, 187, 188, - 189, 190, 191, 192, -1, 194, 195, 196, 197, -1, - 199, 200, 201, 202, 203, 204, 205, -1, 207, -1, - 209, 210, 211, 212, 213, 214, 215, 216, -1, 218, - -1, 220, -1, -1, 223, -1, 225, 226, 227, 228, - 229, 230, -1, -1, 233, -1, 235, -1, -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, -1, - 269, 270, 271, 272, 273, -1, 275, 276, -1, 278, - -1, 280, 281, 282, 283, 284, 285, -1, 287, 288, - -1, -1, 291, 292, 293, -1, -1, 296, 297, 298, - -1, 300, -1, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, -1, -1, -1, -1, 318, - 319, 320, -1, 322, 323, 324, 325, 326, 327, -1, - 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, - 339, 340, 341, 342, 343, -1, 345, 346, 347, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, -1, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - -1, -1, 381, 382, 383, 384, 385, 386, 387, 388, - 389, -1, -1, 392, 393, 394, 395, -1, 397, 398, - 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, -1, -1, 414, 415, -1, 417, -1, - 419, 420, 421, 422, 423, -1, 425, 426, 427, -1, - -1, 430, 431, 432, 433, 434, -1, 436, 437, 438, - 439, 440, 441, 442, 443, -1, -1, 446, 447, 448, - -1, 450, 451, 452, 453, -1, 455, 456, 457, 458, - 459, 460, 461, -1, 463, -1, 465, 466, 467, 468, - 469, 470, 471, -1, -1, 474, -1, -1, 477, 478, - 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, -1, - -1, -1, 501, 502, 503, -1, 505, 506, 507, 508, - 509, 510, 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, 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, -1, - -1, -1, -1, -1, -1, 46, 8, -1, -1, 11, - 176, -1, 53, 15, 16, 17, 18, 19, 20, 21, - -1, -1, -1, -1, -1, -1, -1, 193, -1, -1, - -1, -1, 198, -1, 36, -1, -1, -1, -1, 80, - -1, -1, -1, -1, 46, -1, -1, -1, -1, 176, - -1, 53, -1, -1, -1, 221, 222, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 193, -1, -1, -1, - 236, 198, -1, -1, -1, -1, -1, -1, 80, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 176, -1, - -1, -1, -1, -1, 221, 222, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 193, -1, -1, 274, 236, - 198, 277, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 291, -1, -1, 294, -1, - -1, -1, -1, 221, 222, 176, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 274, 236, -1, - 277, -1, 193, -1, -1, -1, -1, 198, -1, -1, - -1, -1, -1, -1, 291, -1, -1, 294, -1, -1, - -1, -1, -1, -1, 176, -1, -1, -1, -1, -1, - 221, 222, -1, -1, -1, -1, 274, -1, -1, 277, - -1, 193, -1, -1, -1, 236, 198, -1, -1, -1, - -1, -1, -1, 291, -1, -1, 294, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 221, - 222, -1, -1, -1, -1, 391, -1, -1, -1, -1, - -1, -1, -1, 274, 236, -1, 277, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 291, -1, -1, 294, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 391, -1, -1, -1, -1, -1, - -1, -1, 274, -1, -1, 277, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 291, - -1, -1, 294, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 391, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 498, -1, -1, 501, 502, 503, -1, 505, - 506, 507, 508, 509, 510, -1, -1, -1, -1, 515, - 391, -1, -1, -1, -1, -1, 8, -1, -1, 11, - -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, - -1, 498, -1, -1, 501, 502, 503, -1, 505, 506, - 507, 508, 509, 510, 36, -1, -1, -1, 515, 391, - -1, -1, -1, -1, 46, -1, -1, -1, -1, -1, - -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, - 498, -1, -1, 501, 502, 503, -1, 505, 506, 507, - 508, 509, 510, -1, -1, -1, -1, 515, 80, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, 290, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 3, -1, 5, -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, 498, -1, -1, - 501, 502, 503, -1, 505, 506, 507, 508, 509, 510, - 36, -1, -1, -1, 515, -1, -1, -1, -1, -1, - 46, 8, -1, -1, 11, -1, -1, 53, 15, 16, - 17, 18, 19, 20, 21, -1, 498, -1, -1, 501, - 502, 503, -1, 505, 506, 507, 508, 509, 510, 36, - -1, -1, -1, 515, 80, -1, -1, -1, -1, 46, - 8, -1, -1, 11, 176, -1, 53, 15, 16, 17, - 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, - -1, 193, -1, -1, -1, -1, 198, -1, 36, -1, - -1, -1, -1, 80, -1, -1, -1, -1, 46, -1, - -1, -1, -1, -1, -1, 53, -1, -1, -1, 221, - 222, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 236, -1, -1, -1, -1, -1, - -1, -1, 80, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 8, -1, -1, 11, - 176, -1, -1, 15, 16, 17, 18, 19, 20, 21, - -1, -1, 274, -1, -1, 277, -1, 193, -1, -1, - -1, -1, 198, -1, 36, -1, -1, -1, -1, 291, - -1, -1, 294, -1, 46, -1, -1, -1, -1, 176, - -1, 53, -1, -1, -1, 221, 222, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 193, -1, -1, -1, - 236, 198, -1, -1, -1, -1, -1, -1, 80, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 176, -1, - -1, -1, -1, -1, 221, 222, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 193, -1, -1, 274, 236, - 198, 277, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 291, -1, -1, 294, -1, - -1, -1, -1, 221, 222, -1, -1, -1, -1, 391, - -1, -1, -1, -1, -1, -1, -1, 274, 236, -1, - 277, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 291, -1, -1, 294, -1, -1, - -1, -1, -1, -1, 176, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 274, -1, -1, 277, - -1, 193, -1, -1, -1, -1, 198, -1, -1, -1, - -1, -1, -1, 291, -1, -1, 294, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 221, - 222, -1, -1, -1, -1, 391, -1, -1, -1, -1, - -1, -1, -1, -1, 236, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 498, -1, -1, 501, - 502, 503, -1, 505, 506, 507, 508, 509, 510, -1, - -1, -1, -1, 515, 391, -1, -1, -1, -1, -1, - -1, -1, 274, -1, 8, 277, -1, 11, -1, -1, - -1, 15, 16, 17, 18, 19, 20, 21, -1, 291, - -1, -1, 294, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 36, 391, -1, -1, -1, -1, -1, -1, - -1, -1, 46, -1, -1, -1, -1, -1, -1, 53, + -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, 150, 151, 152, 153, 154, 155, 156, + 157, 158, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, 4, -1, -1, -1, -1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 498, -1, -1, 501, 502, 503, -1, 505, - 506, 507, 508, 509, 510, -1, 80, -1, -1, 515, - -1, -1, -1, -1, -1, -1, 8, -1, -1, 11, - -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, - -1, 498, -1, -1, 501, 502, 503, -1, 505, 506, - 507, 508, 509, 510, 36, -1, -1, -1, 515, 391, - -1, -1, -1, -1, 46, 8, -1, -1, 11, -1, - -1, 53, 15, 16, 17, 18, 19, 20, 21, -1, - 498, -1, -1, 501, 502, 503, -1, 505, 506, 507, - 508, 509, 510, 36, -1, -1, -1, 515, 80, -1, - -1, -1, -1, 46, -1, -1, -1, -1, -1, -1, - 53, -1, 176, -1, -1, 8, -1, -1, 11, -1, - -1, -1, 15, 16, 17, 18, 19, 20, 21, 193, - -1, -1, -1, -1, 198, -1, -1, 80, -1, -1, - -1, -1, -1, 36, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 46, -1, -1, -1, 221, 222, -1, - 53, -1, -1, -1, -1, -1, 498, -1, -1, 501, - 502, 503, 236, 505, 506, 507, 508, 509, 510, -1, - -1, -1, -1, 515, -1, -1, -1, 80, -1, -1, - -1, -1, -1, -1, 176, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 274, 193, -1, 277, -1, -1, 198, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 291, -1, -1, - 294, -1, -1, 176, -1, -1, -1, -1, -1, 221, - 222, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 193, -1, -1, -1, 236, 198, -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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, 416, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 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, -1, 221, 222, - -1, -1, -1, 176, -1, -1, -1, -1, -1, -1, - -1, -1, 274, 236, -1, 277, -1, -1, -1, -1, - 193, -1, -1, -1, -1, 198, -1, -1, -1, 291, - -1, -1, 294, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 391, 221, 222, - -1, 274, -1, -1, 277, -1, -1, -1, -1, -1, - -1, -1, -1, 236, -1, -1, -1, -1, 291, -1, - -1, 294, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 274, -1, -1, 277, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 291, -1, - -1, 294, -1, -1, -1, -1, -1, -1, -1, 391, + 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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 498, -1, -1, 501, 502, 503, - -1, 505, 506, 507, 508, 509, 510, -1, 391, 513, + 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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 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, -1, 391, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 498, -1, -1, 501, - 502, 503, -1, 505, 506, 507, 508, 509, 510, -1, - -1, 513, -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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 498, -1, -1, 501, 502, - 503, -1, 505, 506, 507, 508, 509, 510, -1, -1, - 513, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 3, -1, -1, 498, -1, -1, 501, 502, - 503, -1, 505, 506, 507, 508, 509, 510, -1, -1, - 513, 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, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, - 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, - 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, - 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, - 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 3, -1, -1, - -1, -1, -1, -1, -1, -1, 507, -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, -1, 160, -1, 162, 163, 164, 165, - -1, 167, -1, 169, -1, -1, -1, 173, 174, 175, - -1, 177, -1, 179, -1, 181, 182, 183, 184, -1, - 186, 187, 188, 189, 190, 191, 192, -1, 194, 195, - 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, - -1, 207, -1, 209, 210, 211, 212, 213, 214, 215, - 216, -1, 218, -1, 220, -1, -1, 223, -1, 225, - 226, 227, 228, 229, 230, -1, -1, 233, -1, 235, - -1, -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, -1, 269, 270, 271, 272, 273, -1, 275, - 276, -1, 278, -1, 280, 281, 282, 283, 284, 285, - -1, 287, 288, -1, -1, 291, 292, 293, -1, -1, - 296, 297, 298, -1, 300, -1, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, -1, -1, - -1, -1, 318, 319, 320, -1, 322, 323, 324, 325, - 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, - 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, - 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, -1, 359, 360, -1, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, -1, -1, 381, 382, 383, 384, 385, - 386, 387, 388, 389, -1, -1, 392, 393, 394, 395, - -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, - -1, 417, -1, 419, 420, 421, 422, 423, -1, 425, - 426, 427, -1, -1, 430, 431, 432, 433, 434, -1, - 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, - 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, - 456, 457, 458, 459, 460, 461, -1, 463, -1, 465, - 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, - -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 3, -1, -1, -1, -1, -1, -1, -1, - -1, 507, -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, -1, 160, - -1, 162, 163, 164, 165, -1, 167, -1, 169, -1, - -1, -1, 173, 174, 175, -1, 177, -1, 179, -1, - 181, 182, 183, 184, -1, 186, 187, 188, 189, 190, - 191, 192, -1, 194, 195, 196, 197, -1, 199, 200, - 201, 202, 203, 204, 205, -1, 207, -1, 209, 210, - 211, 212, 213, 214, 215, 216, -1, 218, -1, 220, - -1, -1, 223, -1, 225, 226, 227, 228, 229, 230, - -1, -1, 233, -1, 235, -1, -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, -1, 269, 270, - 271, 272, 273, -1, 275, 276, -1, 278, -1, 280, - 281, 282, 283, 284, 285, -1, 287, 288, -1, -1, - 291, 292, 293, -1, -1, 296, 297, 298, -1, 300, - -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, -1, -1, -1, -1, 318, 319, 320, - -1, 322, 323, 324, 325, 326, 327, -1, 329, 330, - 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, - 341, 342, 343, -1, 345, 346, 347, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, -1, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, -1, -1, - 381, 382, 383, 384, 385, 386, 387, 388, 389, -1, - -1, 392, 393, 394, 395, -1, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, -1, -1, 414, 415, -1, 417, -1, 419, 420, - 421, 422, 423, -1, 425, 426, 427, -1, -1, 430, - 431, 432, 433, 434, -1, 436, 437, 438, 439, 440, - 441, 442, 443, -1, -1, 446, 447, 448, -1, 450, - 451, 452, 453, -1, 455, 456, 457, 458, 459, 460, - 461, -1, 463, -1, 465, 466, 467, 468, 469, 470, - 471, -1, -1, 474, -1, -1, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 3, 4, 5, - -1, -1, -1, 9, -1, -1, 507, -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, -1, 162, 163, 164, 165, - -1, 167, -1, 169, 170, -1, 172, 173, 174, 175, - 176, 177, -1, 179, -1, 181, 182, 183, 184, -1, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, -1, 199, 200, 201, 202, 203, 204, 205, - -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, -1, 218, -1, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, -1, -1, 233, 234, 235, - 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, 269, 270, 271, 272, 273, -1, 275, - 276, 277, 278, -1, 280, 281, 282, 283, 284, 285, - -1, 287, 288, 289, -1, 291, 292, 293, -1, -1, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, -1, -1, - -1, -1, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, - 336, 337, 338, 339, 340, 341, 342, 343, -1, 345, - 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, -1, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, -1, 380, 381, 382, 383, 384, 385, - 386, 387, 388, 389, -1, 391, 392, 393, 394, 395, - -1, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, -1, -1, 414, 415, - -1, 417, 418, 419, 420, 421, 422, 423, -1, 425, - 426, 427, -1, -1, 430, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, -1, -1, - 446, 447, 448, -1, 450, 451, 452, 453, -1, 455, - 456, 457, 458, 459, 460, 461, -1, 463, 464, 465, - 466, 467, 468, 469, 470, 471, -1, -1, 474, -1, - -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, -1, -1, 8, -1, -1, 11, -1, 505, - 506, 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, -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, 40, -1, -1, -1, -1, -1, 46, -1, - 8, -1, 176, 11, -1, 53, -1, 15, 16, 17, - 18, 19, 20, 21, -1, -1, -1, -1, -1, 193, - -1, -1, -1, -1, 198, -1, -1, -1, 36, -1, - -1, 166, 80, -1, -1, -1, 171, -1, 46, -1, - -1, 176, -1, -1, -1, 53, -1, 221, 222, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 193, -1, - -1, -1, 236, 198, -1, -1, -1, -1, -1, 165, - -1, -1, 80, -1, -1, -1, -1, -1, -1, -1, - 176, -1, -1, -1, -1, -1, 221, 222, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 193, -1, -1, - 274, 236, 198, 277, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 291, -1, -1, - 294, -1, -1, -1, -1, 221, 222, -1, 176, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 274, - 236, -1, 277, -1, -1, 193, -1, -1, -1, -1, - 198, -1, -1, -1, -1, -1, 291, -1, -1, 294, - -1, -1, -1, -1, -1, -1, -1, -1, 176, -1, - -1, -1, -1, 221, 222, -1, -1, -1, 274, -1, - -1, 277, -1, -1, -1, 193, -1, -1, 236, -1, - 198, -1, -1, -1, -1, 291, -1, -1, 294, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 221, 222, -1, -1, 391, -1, -1, - -1, -1, -1, -1, -1, -1, 274, 323, 236, 277, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 291, -1, -1, 294, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 391, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 274, -1, -1, 277, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 454, -1, -1, 291, -1, -1, 294, -1, -1, -1, - -1, -1, -1, -1, -1, 391, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 317, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 498, -1, -1, 501, 502, 503, - -1, 505, 506, 507, 508, 509, 510, -1, -1, -1, - -1, -1, -1, 391, -1, -1, -1, -1, 8, -1, - -1, 11, -1, -1, -1, 15, 16, 17, 18, 19, - 20, 21, -1, 498, -1, -1, 501, 502, 503, -1, - 505, 506, 507, 508, 509, 510, 36, -1, -1, -1, - 40, -1, -1, 391, -1, -1, 46, -1, -1, -1, - -1, -1, -1, 53, -1, -1, -1, -1, -1, -1, - -1, -1, 498, -1, -1, 501, 502, 503, -1, 505, - 506, 507, 508, 509, 510, -1, -1, -1, -1, -1, - 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, - 498, -1, -1, 501, 502, 503, -1, 505, 506, 507, - 508, 509, 510, 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, - 498, -1, -1, 501, 502, 503, -1, 505, 506, 507, - 508, 509, 510, -1, -1, -1, -1, 80, -1, -1, - -1, -1, 8, -1, -1, 11, 176, -1, -1, 15, - 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, - -1, -1, -1, 193, -1, -1, -1, -1, 198, -1, - 36, -1, -1, -1, 40, -1, -1, -1, -1, -1, - 46, -1, -1, -1, -1, -1, -1, 53, -1, -1, - -1, 221, 222, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 236, -1, -1, -1, - -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 171, 8, - -1, -1, 11, 176, -1, -1, 15, 16, 17, 18, - 19, 20, 21, -1, 274, -1, -1, 277, -1, -1, - 193, -1, -1, -1, -1, 198, -1, 36, -1, -1, - -1, 291, -1, -1, 294, -1, -1, 46, -1, -1, - -1, -1, -1, -1, 53, -1, -1, -1, 221, 222, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 236, -1, -1, -1, -1, -1, -1, - -1, 80, -1, -1, -1, -1, -1, -1, -1, -1, - 176, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 193, -1, -1, - -1, 274, 198, -1, 277, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 291, -1, - -1, 294, -1, -1, -1, 221, 222, -1, -1, -1, - -1, 391, -1, -1, 8, -1, -1, 11, -1, -1, - 236, 15, 16, 17, 18, 19, 20, 21, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 166, -1, -1, - -1, -1, 36, -1, -1, -1, -1, 176, -1, -1, - -1, -1, 46, -1, -1, -1, -1, -1, 274, 53, - -1, 277, -1, -1, 193, -1, -1, -1, -1, 198, - -1, -1, -1, -1, -1, 291, -1, -1, 294, -1, - -1, -1, -1, -1, -1, -1, 80, -1, -1, -1, - -1, -1, 221, 222, -1, -1, -1, -1, 391, -1, - -1, -1, -1, -1, -1, -1, -1, 236, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 498, -1, - -1, 501, 502, 503, -1, 505, 506, 507, 508, 509, - 510, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 274, -1, -1, 277, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 291, -1, -1, 294, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 391, -1, -1, -1, -1, - -1, -1, 176, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 193, - -1, -1, -1, -1, 198, 498, -1, -1, 501, 502, - 503, -1, 505, 506, 507, 508, 509, 510, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 221, 222, -1, - -1, -1, -1, -1, -1, -1, 8, -1, -1, 11, - -1, -1, 236, 15, 16, 17, 18, 19, 20, 21, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 391, -1, 36, -1, -1, -1, 40, -1, - -1, -1, -1, -1, 46, -1, -1, -1, -1, -1, - 274, 53, 498, 277, -1, 501, 502, 503, -1, 505, - 506, 507, 508, 509, 510, -1, -1, 291, -1, -1, - 294, -1, -1, -1, -1, -1, -1, -1, 80, -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, -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, -1, -1, 498, - -1, -1, 501, 502, 503, -1, 505, 506, 507, 508, - 509, 510, 80, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 391, -1, 8, - -1, -1, 11, -1, 176, -1, 15, 16, 17, 18, - 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, - -1, 193, -1, -1, -1, -1, 198, 36, -1, -1, - 424, -1, -1, -1, -1, -1, -1, 46, -1, -1, - -1, -1, -1, -1, 53, -1, -1, -1, -1, 221, - 222, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 236, -1, -1, -1, -1, -1, - -1, 80, -1, -1, -1, -1, -1, -1, 176, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 193, -1, -1, -1, -1, - 198, -1, 274, -1, 498, 277, -1, 501, 502, 503, - -1, 505, 506, 507, 508, 509, 510, -1, -1, 291, - -1, -1, 294, 221, 222, -1, -1, -1, -1, -1, - -1, -1, 8, -1, -1, 11, -1, -1, 236, 15, - 16, 17, 18, 19, 20, 21, -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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 36, -1, -1, -1, -1, -1, -1, 176, -1, -1, - 46, -1, -1, -1, -1, -1, 274, 53, -1, 277, - -1, -1, -1, -1, 193, -1, -1, -1, -1, 198, - -1, -1, -1, 291, -1, -1, 294, -1, -1, -1, - -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, - -1, -1, 221, 222, -1, -1, -1, -1, -1, 391, - -1, -1, -1, -1, -1, -1, -1, 236, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 8, -1, - -1, 11, -1, -1, -1, 15, 16, -1, -1, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 274, 36, -1, 277, -1, - -1, -1, -1, -1, -1, -1, 46, -1, -1, -1, - -1, -1, 291, 53, -1, 294, -1, -1, -1, -1, - -1, -1, -1, 391, 8, -1, -1, 11, -1, -1, - 176, 15, 16, -1, -1, 19, 20, 21, -1, -1, - 80, -1, -1, -1, -1, -1, -1, 193, -1, -1, - -1, -1, 198, -1, -1, -1, 498, -1, -1, 501, - 502, 503, 46, 505, 506, 507, 508, 509, 510, 53, - -1, 8, -1, -1, 11, 221, 222, -1, 15, 16, - -1, -1, 19, 20, 21, -1, -1, -1, -1, -1, - 236, -1, -1, -1, -1, -1, 80, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 46, - -1, 8, 391, -1, 11, -1, 53, -1, 15, 16, - -1, -1, 19, 20, 21, -1, -1, -1, 274, -1, - 498, 277, -1, 501, 502, 503, 176, 505, 506, 507, - 508, 509, 510, 80, -1, 291, -1, -1, 294, 46, - -1, -1, -1, 193, -1, -1, 53, -1, 198, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 221, 222, 80, -1, -1, -1, -1, -1, -1, - -1, -1, 176, -1, -1, -1, 236, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 193, - -1, -1, -1, -1, 198, -1, -1, -1, -1, 498, - -1, -1, 501, 502, 503, -1, 505, 506, 507, 508, - 509, 510, -1, -1, 274, -1, -1, 277, -1, 176, - -1, -1, -1, -1, -1, 391, -1, -1, -1, -1, - -1, 291, 236, -1, 294, -1, 193, -1, -1, -1, - -1, 198, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 176, - -1, -1, -1, -1, 221, 222, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 193, -1, -1, 236, - -1, 198, -1, -1, -1, -1, -1, 291, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 221, 222, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 274, -1, 236, - 277, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 391, 498, -1, 291, 501, 502, 503, -1, 505, - 506, 507, 508, 509, 510, -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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 277, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 291, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 391, -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, -1, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, 170, -1, + 172, 173, 174, 175, 176, 177, -1, 179, -1, -1, + -1, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, 208, -1, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, -1, + -1, 233, 234, 235, 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, 269, 270, 271, + 272, -1, -1, 275, 276, 277, 278, -1, -1, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, -1, 299, 300, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, -1, 321, + 322, 323, -1, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, 361, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, 380, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, 391, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, -1, + -1, -1, 414, 415, -1, 417, 418, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + -1, 433, -1, -1, 436, 437, 438, 439, 440, 441, + 442, 443, 444, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, -1, 461, + -1, 463, 464, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 3, -1, 5, -1, -1, -1, -1, -1, -1, + -1, -1, 494, 495, 496, 497, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 391, -1, -1, -1, 498, -1, - -1, 501, 502, 503, -1, 505, 506, 507, 508, 509, - 510, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 391, -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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 498, -1, -1, 501, 502, 503, - -1, 505, 506, 507, 508, 509, 510, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, -1, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 498, -1, -1, 501, 502, 503, -1, 505, 506, - 507, 508, 509, 510, -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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 3, -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, 498, -1, -1, 501, 502, 503, -1, 505, 506, - 507, 508, 509, 510, 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, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, - 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, - 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, - 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, - 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, - 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, - 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, - 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, - 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, - 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, - 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, - 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, - 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, - 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, - 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, 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, -1, 162, - 163, 164, 165, -1, 167, -1, 169, 170, -1, 172, - 173, 174, 175, 176, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, - 233, 234, 235, 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, 269, 270, 271, 272, - 273, -1, 275, 276, 277, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, 289, -1, 291, 292, - 293, -1, -1, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, 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, -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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, 170, -1, 172, 173, 174, 175, 176, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, -1, 275, 276, 277, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, 464, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, 170, -1, 172, - 173, 174, 175, 176, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, - 233, 234, 235, 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, 269, 270, 271, 272, - 273, -1, 275, 276, 277, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, 170, -1, 172, 173, 174, 175, 176, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, 273, -1, 275, 276, 277, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, 464, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, 168, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, 445, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - 168, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, 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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, 445, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, -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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, 290, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, 290, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 3, 4, -1, -1, -1, - -1, 9, -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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, 416, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, 150, 151, 152, 153, 154, 155, 156, 157, - 158, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, 150, 151, 152, 153, 154, 155, 156, 157, - 158, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, - -1, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, 170, -1, 172, 173, 174, 175, 176, 177, - -1, 179, -1, -1, -1, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - 208, -1, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, -1, -1, 275, 276, 277, - 278, -1, -1, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - -1, 299, 300, 301, -1, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, -1, 321, 322, 323, -1, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, -1, -1, -1, 414, 415, -1, 417, - 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, -1, 433, -1, -1, 436, 437, - 438, 439, 440, 441, 442, 443, 444, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, -1, 461, -1, 463, 464, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 3, -1, 5, -1, -1, - -1, -1, -1, -1, -1, -1, 494, 495, 496, 497, - -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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 3, -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, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, -1, -1, + -1, 173, 174, 175, -1, 177, -1, 179, -1, 181, + 182, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, -1, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, -1, 209, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, -1, + -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -1, 235, -1, -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, -1, 269, 270, 271, + 272, 273, -1, 275, 276, -1, 278, -1, 280, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, 298, -1, 300, -1, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, 320, -1, + 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, -1, 381, + 382, 383, 384, 385, 386, 387, 388, 389, -1, -1, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + -1, -1, 414, 415, -1, 417, -1, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + 432, 433, 434, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, 460, 461, + -1, 463, -1, 465, 466, 467, 468, 469, 470, 471, + -1, -1, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 3, -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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, + 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, -1, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, 170, -1, 172, 173, 174, -1, 176, + 177, -1, 179, -1, -1, -1, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, -1, -1, 275, 276, + 277, 278, -1, -1, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, -1, 299, 300, 301, -1, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, -1, 321, 322, 323, -1, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, 380, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, 391, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, -1, -1, -1, 414, 415, -1, + 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, -1, 433, -1, -1, 436, + 437, 438, 439, 440, 441, 442, 443, 444, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, -1, 461, -1, 463, 464, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 3, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 494, 495, 496, + 497, -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, -1, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, 170, -1, 172, 173, 174, -1, 176, + 177, -1, 179, -1, -1, -1, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, -1, -1, 275, 276, + 277, 278, -1, -1, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, -1, 299, 300, 301, -1, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, -1, 321, 322, 323, -1, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, 380, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, 391, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, -1, -1, -1, 414, 415, -1, + 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, -1, 433, -1, -1, 436, + 437, 438, 439, 440, 441, 442, 443, 444, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, -1, 461, -1, 463, 464, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 3, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 494, 495, 496, + 497, -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, -1, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, 170, -1, 172, 173, 174, 175, 176, + 177, -1, 179, -1, -1, -1, 183, 184, -1, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, -1, -1, 233, 234, 235, 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, 269, 270, 271, 272, -1, -1, 275, 276, + 277, 278, -1, -1, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, -1, 299, 300, 301, -1, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, -1, 321, 322, 323, -1, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, 361, 362, 363, 364, -1, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, 380, 381, 382, 383, 384, 385, 386, + -1, 388, 389, -1, 391, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, -1, -1, -1, 414, 415, -1, + 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, -1, 433, -1, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, -1, 461, -1, 463, 464, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 3, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 494, 495, 496, + 497, -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, -1, 160, -1, 162, 163, 164, 165, -1, + 167, -1, 169, -1, -1, -1, 173, 174, 175, -1, + 177, -1, 179, -1, 181, 182, -1, 184, -1, 186, + 187, 188, 189, 190, 191, 192, -1, 194, 195, 196, + 197, -1, 199, 200, 201, 202, 203, 204, 205, -1, + 207, -1, 209, 210, 211, 212, 213, 214, 215, 216, + -1, 218, -1, 220, -1, -1, 223, -1, 225, 226, + 227, 228, 229, 230, -1, -1, 233, -1, 235, -1, + -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, -1, 269, 270, 271, 272, 273, -1, 275, 276, + -1, 278, -1, 280, 281, 282, 283, 284, 285, -1, + 287, 288, -1, -1, 291, 292, 293, -1, -1, 296, + 297, 298, -1, 300, -1, 302, 303, 304, 305, 306, + 307, 308, -1, 310, 311, 312, 313, -1, -1, -1, + -1, 318, 319, 320, -1, 322, 323, 324, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + -1, 338, 339, 340, 341, 342, 343, -1, 345, 346, + 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, -1, 359, 360, -1, 362, 363, 364, 365, -1, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, -1, -1, 381, 382, 383, 384, 385, 386, + 387, 388, 389, -1, -1, 392, 393, 394, 395, -1, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, -1, -1, 414, 415, -1, + 417, -1, 419, 420, 421, 422, 423, -1, 425, 426, + 427, -1, -1, 430, 431, 432, 433, 434, -1, 436, + 437, 438, 439, 440, 441, 442, 443, -1, -1, 446, + 447, 448, -1, 450, 451, 452, 453, -1, 455, 456, + 457, 458, 459, 460, 461, -1, 463, -1, 465, 466, + 467, 468, 469, 470, 471, -1, -1, 474, -1, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 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, -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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, -1, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 3, -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, -1, -1, 160, -1, + 162, 163, 164, 165, -1, 167, -1, 169, 170, -1, + 172, 173, 174, -1, 176, 177, -1, 179, -1, -1, + -1, 183, 184, -1, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, -1, 199, 200, 201, + 202, 203, 204, 205, -1, 207, 208, -1, 210, 211, + 212, 213, 214, 215, 216, -1, 218, -1, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, -1, + -1, 233, 234, 235, 236, -1, 238, 239, 240, 241, + 242, 243, 244, 245, -1, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, -1, -1, 275, 276, 277, 278, -1, -1, 281, + 282, 283, 284, 285, -1, 287, 288, -1, -1, 291, + 292, 293, -1, -1, 296, 297, -1, 299, 300, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, -1, -1, -1, -1, 318, 319, -1, 321, + 322, 323, -1, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + 342, 343, -1, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, -1, 359, 360, 361, + 362, 363, 364, -1, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, -1, 380, 381, + 382, 383, 384, 385, 386, -1, 388, 389, -1, 391, + 392, 393, 394, 395, -1, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, -1, 410, -1, + -1, -1, 414, 415, -1, 417, 418, 419, 420, 421, + 422, 423, -1, 425, 426, 427, -1, -1, 430, 431, + -1, 433, -1, -1, 436, 437, 438, 439, 440, 441, + 442, 443, -1, -1, 446, 447, 448, -1, 450, 451, + 452, 453, -1, 455, 456, 457, 458, 459, -1, 461, + -1, 463, 464, 465, 466, 467, 468, 469, 470, 471, + -1, 22, 474, -1, -1, 477, 478, 479, 480, 481, + 482, 32, -1, 34, 35, -1, -1, -1, -1, 22, + -1, -1, 494, 495, 496, 497, -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, 167, -1, 151, -1, + 171, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 167, -1, -1, -1, 171, -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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 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, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, -1, -1, -1, 173, 174, 175, -1, 177, - -1, 179, -1, 181, 182, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, -1, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - -1, 209, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, -1, -1, 223, -1, 225, 226, 227, - 228, 229, 230, -1, -1, 233, -1, 235, -1, -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, - -1, 269, 270, 271, 272, 273, -1, 275, 276, -1, - 278, -1, 280, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - 298, -1, 300, -1, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, 320, -1, 322, 323, 324, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, -1, 381, 382, 383, 384, 385, 386, 387, - 388, 389, -1, -1, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, -1, -1, 414, 415, -1, 417, - -1, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, 432, 433, 434, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, 460, 461, -1, 463, -1, 465, 466, 467, - 468, 469, 470, 471, -1, -1, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 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, -1, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, 170, -1, 172, - 173, 174, -1, 176, 177, -1, 179, -1, -1, -1, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, 208, -1, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, - 233, 234, 235, 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, 269, 270, 271, 272, - -1, -1, 275, 276, 277, 278, -1, -1, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, -1, 299, 300, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, -1, 321, 322, - 323, -1, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, -1, -1, - -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, -1, - 433, -1, -1, 436, 437, 438, 439, 440, 441, 442, - 443, 444, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, -1, 461, -1, - 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 494, 495, 496, 497, -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, -1, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, 170, -1, 172, - 173, 174, -1, 176, 177, -1, 179, -1, -1, -1, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, 208, -1, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, - 233, 234, 235, 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, 269, 270, 271, 272, - -1, -1, 275, 276, 277, 278, -1, -1, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, -1, 299, 300, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, -1, 321, 322, - 323, -1, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, 391, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, -1, -1, - -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, -1, - 433, -1, -1, 436, 437, 438, 439, 440, 441, 442, - 443, 444, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, -1, 461, -1, - 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 494, 495, 496, 497, -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, -1, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, 170, -1, 172, - 173, 174, 175, 176, 177, -1, 179, -1, -1, -1, - 183, 184, -1, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, 208, -1, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, -1, -1, - 233, 234, 235, 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, 269, 270, 271, 272, - -1, -1, 275, 276, 277, 278, -1, -1, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, -1, 299, 300, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, -1, 321, 322, - 323, -1, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, 361, 362, - 363, 364, -1, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, 380, 381, 382, - 383, 384, 385, 386, -1, 388, 389, -1, 391, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, -1, -1, - -1, 414, 415, -1, 417, 418, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, -1, - 433, -1, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, -1, 461, -1, - 463, 464, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 494, 495, 496, 497, -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, -1, 160, -1, 162, - 163, 164, 165, -1, 167, -1, 169, -1, -1, -1, - 173, 174, 175, -1, 177, -1, 179, -1, 181, 182, - -1, 184, -1, 186, 187, 188, 189, 190, 191, 192, - -1, 194, 195, 196, 197, -1, 199, 200, 201, 202, - 203, 204, 205, -1, 207, -1, 209, 210, 211, 212, - 213, 214, 215, 216, -1, 218, -1, 220, -1, -1, - 223, -1, 225, 226, 227, 228, 229, 230, -1, -1, - 233, -1, 235, -1, -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, -1, 269, 270, 271, 272, - 273, -1, 275, 276, -1, 278, -1, 280, 281, 282, - 283, 284, 285, -1, 287, 288, -1, -1, 291, 292, - 293, -1, -1, 296, 297, 298, -1, 300, -1, 302, - 303, 304, 305, 306, 307, 308, -1, 310, 311, 312, - 313, -1, -1, -1, -1, 318, 319, 320, -1, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, -1, 338, 339, 340, 341, 342, - 343, -1, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, -1, 359, 360, -1, 362, - 363, 364, 365, -1, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, -1, -1, 381, 382, - 383, 384, 385, 386, 387, 388, 389, -1, -1, 392, - 393, 394, 395, -1, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, -1, - -1, 414, 415, -1, 417, -1, 419, 420, 421, 422, - 423, -1, 425, 426, 427, -1, -1, 430, 431, 432, - 433, 434, -1, 436, 437, 438, 439, 440, 441, 442, - 443, -1, -1, 446, 447, 448, -1, 450, 451, 452, - 453, -1, 455, 456, 457, 458, 459, 460, 461, -1, - 463, -1, 465, 466, 467, 468, 469, 470, 471, -1, - -1, 474, -1, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 3, -1, -1, -1, -1, + -1, -1, 213, -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, - -1, -1, 160, -1, 162, 163, 164, 165, -1, 167, - -1, 169, 170, -1, 172, 173, 174, -1, 176, 177, - -1, 179, -1, -1, -1, 183, 184, -1, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - -1, 199, 200, 201, 202, 203, 204, 205, -1, 207, - 208, -1, 210, 211, 212, 213, 214, 215, 216, -1, - 218, -1, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, -1, -1, 233, 234, 235, 236, -1, - 238, 239, 240, 241, 242, 243, 244, 245, -1, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, -1, -1, 275, 276, 277, - 278, -1, -1, 281, 282, 283, 284, 285, -1, 287, - 288, -1, -1, 291, 292, 293, -1, -1, 296, 297, - -1, 299, 300, 301, -1, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, - 318, 319, -1, 321, 322, 323, -1, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, 342, 343, -1, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - -1, 359, 360, 361, 362, 363, 364, -1, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, -1, 380, 381, 382, 383, 384, 385, 386, -1, - 388, 389, -1, 391, 392, 393, 394, 395, -1, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, -1, 410, -1, -1, -1, 414, 415, -1, 417, - 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, - -1, -1, 430, 431, -1, 433, -1, -1, 436, 437, - 438, 439, 440, 441, 442, 443, -1, -1, 446, 447, - 448, -1, 450, 451, 452, 453, -1, 455, 456, 457, - 458, 459, -1, 461, -1, 463, 464, 465, 466, 467, - 468, 469, 470, 471, -1, 22, 474, -1, -1, 477, - 478, 479, 480, 481, 482, 32, -1, 34, 35, -1, - -1, -1, -1, 22, -1, -1, 494, 495, 496, 497, - -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, - 167, -1, 151, -1, 171, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 167, -1, - -1, -1, 171, -1, -1, -1, -1, -1, -1, -1, + 213, -1, -1, -1, -1, -1, -1, -1, 239, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 213, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 239, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 213, -1, -1, -1, -1, -1, - -1, -1, 239, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 239, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 314, 315, 316, -1, -1, -1, -1, + -1, 322, -1, -1, 325, -1, -1, -1, -1, -1, + -1, 314, 315, 316, -1, -1, -1, -1, -1, 322, + -1, -1, 325, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 354, -1, -1, -1, -1, -1, -1, + -1, -1, 363, -1, -1, -1, -1, -1, -1, -1, + -1, 354, -1, -1, -1, -1, -1, -1, 379, -1, + 363, -1, -1, -1, -1, 386, -1, -1, -1, 390, + -1, -1, -1, -1, -1, -1, 379, -1, -1, 400, + -1, -1, -1, 386, -1, -1, -1, 390, -1, -1, + -1, 412, -1, -1, -1, 416, -1, 400, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 412, + -1, -1, -1, 416, -1, 436, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 449, -1, + -1, -1, -1, 436, 455, -1, -1, -1, -1, 460, + -1, -1, -1, 464, -1, -1, 449, -1, -1, -1, + -1, -1, 455, -1, -1, 476, -1, 460, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 314, 315, 316, - -1, -1, -1, -1, -1, 322, -1, -1, 325, -1, - -1, -1, -1, -1, -1, 314, 315, 316, -1, -1, - -1, -1, -1, 322, -1, -1, 325, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 354, -1, -1, - -1, -1, -1, -1, -1, -1, 363, -1, -1, -1, - -1, -1, -1, -1, -1, 354, -1, -1, -1, -1, - -1, -1, 379, -1, 363, -1, -1, -1, -1, 386, - -1, -1, -1, 390, -1, -1, -1, -1, -1, -1, - 379, -1, -1, 400, -1, -1, -1, 386, -1, -1, - -1, 390, -1, -1, -1, 412, -1, -1, -1, 416, - -1, 400, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 412, -1, -1, -1, 416, -1, 436, + -1, -1, -1, 476, -1, -1, -1, -1, -1, 500, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 449, -1, -1, -1, -1, 436, 455, -1, - -1, -1, -1, 460, -1, -1, -1, 464, -1, -1, - 449, -1, -1, -1, -1, -1, 455, -1, -1, 476, - -1, 460, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 476, -1, -1, - -1, -1, -1, 500, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 514, -1, -1, - -1, 500, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 514 + -1, -1, -1, 514, -1, -1, -1, 500, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 514 }; -/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of - state STATE-NUM. */ -static const yytype_int16 yystos[] = +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint16 yystos[] = { 0, 22, 32, 34, 35, 47, 52, 61, 75, 84, 86, 98, 100, 111, 126, 127, 128, 137, 143, 151, 153, 154, 167, 171, 197, 213, 239, 314, 315, 316, 322, 325, 354, 363, 379, 386, 390, 400, 412, 416, 436, 449, 452, 455, 460, 476, 500, 514, 526, 527, - 528, 529, 530, 537, 548, 549, 550, 553, 554, 556, - 567, 585, 633, 643, 646, 649, 653, 655, 658, 659, - 663, 669, 671, 675, 682, 686, 687, 688, 695, 700, - 716, 719, 720, 723, 725, 726, 727, 728, 730, 732, - 733, 737, 790, 791, 957, 959, 960, 961, 966, 969, - 975, 976, 977, 981, 430, 479, 958, 202, 370, 381, - 416, 466, 108, 191, 551, 958, 3, 22, 23, 24, + 528, 529, 540, 549, 551, 556, 572, 575, 576, 578, + 582, 586, 593, 595, 597, 598, 646, 652, 655, 656, + 674, 675, 676, 677, 679, 681, 682, 686, 739, 740, + 907, 910, 913, 920, 921, 923, 926, 927, 928, 935, + 939, 945, 948, 953, 957, 958, 959, 962, 965, 966, + 967, 971, 972, 974, 430, 479, 596, 202, 370, 381, + 416, 466, 108, 191, 960, 596, 3, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 33, 42, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 67, @@ -404057,11 +408793,11 @@ static const yytype_int16 yystos[] = 457, 458, 459, 460, 461, 463, 464, 465, 466, 467, 468, 469, 470, 471, 474, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 560, 636, 637, 638, - 866, 946, 950, 3, 175, 246, 409, 555, 560, 636, - 289, 958, 55, 171, 514, 580, 177, 240, 294, 313, - 370, 420, 422, 439, 445, 448, 631, 651, 694, 5, - 30, 325, 560, 561, 945, 3, 30, 34, 35, 36, + 492, 493, 494, 495, 496, 497, 542, 816, 896, 900, + 977, 978, 979, 3, 175, 246, 409, 542, 922, 977, + 289, 596, 55, 171, 514, 669, 177, 240, 294, 313, + 370, 420, 422, 439, 445, 448, 580, 644, 919, 5, + 30, 325, 542, 543, 895, 3, 30, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 49, 53, 54, 55, 56, 57, 58, 65, 66, 71, 72, 74, 79, 80, 81, 82, 83, 89, 93, 100, 101, 108, 112, @@ -404077,785 +408813,379 @@ static const yytype_int16 yystos[] = 418, 424, 426, 427, 428, 429, 432, 434, 435, 438, 444, 445, 449, 454, 460, 461, 462, 464, 472, 473, 475, 476, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 566, 636, 640, 642, 24, 81, 97, + 491, 492, 493, 548, 977, 981, 983, 24, 81, 97, 146, 156, 168, 173, 202, 245, 249, 319, 334, 367, 370, 381, 384, 402, 416, 422, 423, 433, 439, 466, - 651, 664, 665, 668, 958, 945, 100, 137, 464, 514, - 529, 530, 537, 553, 554, 567, 585, 633, 643, 646, - 653, 655, 658, 659, 663, 671, 678, 682, 688, 695, - 716, 719, 720, 723, 725, 957, 959, 961, 966, 969, - 975, 981, 108, 75, 213, 66, 79, 81, 158, 231, + 580, 647, 648, 651, 596, 895, 100, 137, 464, 514, + 529, 540, 549, 551, 572, 575, 576, 582, 586, 595, + 598, 646, 652, 655, 656, 674, 907, 910, 913, 920, + 921, 931, 935, 939, 945, 948, 953, 962, 965, 971, + 972, 974, 108, 75, 213, 66, 79, 81, 158, 231, 280, 290, 302, 320, 366, 411, 432, 434, 438, 460, - 514, 559, 560, 561, 726, 791, 793, 795, 805, 812, - 813, 866, 868, 869, 108, 5, 560, 562, 717, 717, - 560, 945, 30, 177, 240, 385, 426, 430, 560, 967, - 968, 979, 958, 30, 132, 746, 747, 177, 240, 370, - 385, 426, 970, 971, 979, 958, 560, 725, 737, 980, - 560, 812, 416, 743, 559, 172, 514, 963, 514, 342, - 738, 739, 945, 738, 726, 727, 975, 0, 517, 464, - 676, 122, 212, 451, 147, 217, 295, 444, 749, 750, - 795, 795, 726, 728, 730, 518, 30, 426, 430, 725, - 980, 191, 559, 945, 191, 559, 191, 812, 191, 559, - 274, 562, 512, 516, 563, 564, 514, 82, 108, 173, - 202, 245, 370, 381, 416, 439, 466, 558, 108, 725, - 559, 420, 422, 420, 422, 352, 191, 559, 559, 173, - 245, 342, 381, 416, 466, 644, 377, 202, 30, 945, - 191, 566, 251, 433, 107, 416, 416, 466, 374, 377, - 191, 560, 666, 952, 191, 942, 945, 191, 945, 514, - 674, 294, 422, 678, 3, 460, 636, 640, 679, 681, - 682, 684, 685, 676, 560, 562, 555, 717, 514, 514, - 166, 514, 726, 813, 514, 514, 559, 514, 514, 171, - 514, 514, 514, 514, 726, 791, 795, 805, 507, 563, - 40, 560, 806, 807, 806, 379, 518, 729, 37, 42, + 514, 541, 542, 543, 675, 740, 742, 744, 754, 761, + 762, 816, 818, 819, 108, 5, 542, 544, 946, 946, + 542, 895, 30, 177, 240, 385, 426, 430, 542, 963, + 964, 969, 596, 30, 132, 695, 696, 177, 240, 370, + 385, 426, 940, 941, 969, 596, 542, 674, 686, 970, + 542, 761, 416, 692, 541, 172, 514, 950, 514, 342, + 687, 688, 895, 687, 675, 676, 965, 0, 517, 122, + 212, 451, 147, 217, 295, 444, 698, 699, 744, 744, + 675, 677, 679, 518, 464, 929, 30, 426, 430, 674, + 970, 191, 541, 895, 191, 541, 191, 761, 191, 541, + 274, 544, 512, 516, 545, 546, 514, 82, 108, 173, + 202, 245, 370, 381, 416, 439, 466, 925, 108, 674, + 541, 420, 422, 420, 422, 352, 191, 541, 541, 377, + 173, 245, 342, 381, 416, 466, 653, 202, 30, 895, + 191, 548, 251, 433, 107, 416, 416, 466, 374, 377, + 191, 542, 649, 902, 191, 892, 895, 191, 895, 514, + 585, 294, 422, 931, 3, 460, 932, 934, 935, 937, + 938, 977, 981, 929, 542, 544, 922, 946, 514, 514, + 166, 514, 675, 762, 514, 514, 541, 514, 514, 171, + 514, 514, 514, 514, 675, 740, 744, 754, 507, 545, + 40, 542, 755, 756, 755, 379, 518, 678, 37, 42, 101, 172, 208, 224, 234, 268, 314, 321, 361, 380, - 449, 809, 807, 40, 560, 806, 808, 500, 817, 562, - 171, 503, 514, 514, 721, 968, 968, 968, 497, 223, + 449, 758, 756, 40, 542, 755, 757, 500, 766, 544, + 171, 503, 514, 514, 908, 964, 964, 964, 497, 223, 516, 289, 4, 6, 7, 8, 9, 10, 39, 54, 56, 57, 65, 71, 72, 83, 112, 115, 117, 136, 152, 159, 164, 181, 182, 215, 216, 218, 246, 267, 269, 274, 279, 282, 291, 339, 365, 394, 426, 427, 435, 461, 498, 505, 506, 507, 512, 514, 519, 520, - 521, 522, 560, 562, 726, 780, 829, 832, 835, 836, - 837, 839, 840, 841, 842, 844, 845, 860, 862, 863, - 864, 865, 866, 867, 869, 870, 885, 886, 897, 919, - 924, 932, 933, 934, 946, 947, 948, 931, 933, 970, - 970, 562, 970, 497, 171, 428, 503, 516, 563, 660, - 812, 3, 170, 172, 464, 682, 962, 964, 170, 965, - 860, 903, 904, 738, 518, 514, 954, 515, 515, 515, - 528, 559, 171, 294, 703, 660, 30, 132, 744, 744, - 59, 744, 161, 166, 237, 286, 755, 757, 758, 783, - 785, 786, 787, 180, 289, 454, 289, 749, 750, 514, - 417, 978, 497, 223, 152, 26, 32, 137, 293, 350, - 354, 386, 457, 542, 545, 546, 350, 152, 40, 60, - 106, 201, 250, 260, 272, 304, 350, 356, 381, 386, - 400, 531, 534, 545, 152, 350, 386, 545, 152, 350, - 386, 545, 152, 40, 552, 860, 925, 565, 566, 564, - 3, 30, 37, 42, 49, 55, 81, 83, 89, 101, - 132, 170, 172, 175, 176, 193, 208, 221, 222, 224, - 234, 236, 246, 268, 277, 299, 301, 321, 361, 380, - 391, 409, 418, 438, 462, 464, 515, 636, 641, 860, - 906, 907, 949, 955, 860, 416, 559, 560, 515, 514, - 620, 370, 631, 651, 274, 647, 40, 466, 191, 559, - 191, 559, 635, 191, 559, 191, 559, 191, 560, 650, - 89, 691, 152, 480, 90, 129, 307, 421, 191, 560, - 152, 516, 953, 63, 357, 518, 667, 152, 518, 667, - 152, 289, 672, 673, 860, 955, 352, 515, 518, 4, - 159, 289, 435, 505, 506, 533, 536, 562, 677, 679, - 680, 683, 948, 678, 428, 514, 575, 579, 171, 860, - 904, 514, 3, 68, 69, 109, 110, 113, 114, 188, - 189, 252, 253, 254, 255, 256, 257, 258, 259, 262, - 263, 375, 376, 470, 471, 494, 495, 562, 847, 848, - 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, - 909, 910, 807, 808, 860, 559, 860, 911, 505, 506, - 560, 861, 862, 886, 897, 913, 514, 860, 903, 914, - 860, 58, 171, 232, 429, 860, 904, 917, 860, 515, - 561, 514, 418, 763, 764, 764, 746, 747, 795, 219, - 741, 37, 224, 380, 809, 224, 299, 810, 795, 810, - 224, 809, 514, 224, 810, 148, 199, 797, 224, 764, - 514, 561, 514, 764, 296, 560, 562, 718, 860, 972, - 974, 906, 3, 37, 42, 49, 54, 55, 56, 57, - 71, 72, 81, 83, 89, 101, 112, 115, 164, 170, - 172, 176, 193, 208, 215, 216, 218, 221, 222, 224, - 234, 236, 246, 267, 268, 269, 277, 282, 299, 301, - 321, 339, 361, 365, 380, 387, 391, 394, 409, 418, - 426, 427, 438, 444, 461, 464, 636, 639, 823, 825, - 826, 828, 830, 832, 834, 836, 837, 838, 840, 841, - 844, 845, 908, 951, 40, 235, 560, 514, 512, 726, - 463, 843, 860, 923, 843, 843, 514, 514, 831, 831, - 324, 726, 514, 833, 522, 71, 72, 843, 860, 831, - 514, 514, 478, 500, 514, 846, 514, 846, 860, 860, - 860, 148, 935, 936, 860, 904, 905, 726, 860, 903, - 9, 566, 561, 887, 888, 889, 516, 563, 926, 563, - 514, 562, 514, 514, 562, 948, 3, 8, 11, 15, - 16, 17, 18, 19, 20, 21, 36, 40, 46, 53, - 80, 176, 193, 198, 221, 222, 236, 274, 277, 291, - 294, 391, 498, 501, 502, 503, 505, 506, 507, 508, - 509, 510, 895, 896, 897, 899, 929, 477, 871, 301, - 860, 518, 741, 514, 562, 741, 3, 117, 240, 533, - 562, 845, 973, 104, 974, 974, 560, 40, 560, 515, - 518, 676, 518, 515, 739, 942, 943, 40, 954, 660, - 192, 352, 219, 386, 728, 728, 30, 751, 752, 860, - 59, 728, 745, 163, 271, 771, 226, 272, 338, 389, - 451, 4, 9, 30, 766, 860, 505, 506, 767, 768, - 860, 862, 783, 784, 758, 757, 755, 756, 166, 786, - 284, 788, 59, 734, 735, 736, 798, 861, 933, 933, - 755, 783, 904, 235, 559, 74, 82, 93, 168, 191, - 328, 445, 560, 602, 612, 627, 82, 93, 724, 93, - 724, 514, 428, 514, 600, 244, 448, 600, 93, 518, - 428, 559, 3, 828, 533, 59, 535, 533, 533, 106, - 250, 260, 59, 428, 476, 500, 532, 265, 370, 532, - 534, 812, 93, 428, 724, 370, 559, 428, 370, 551, - 560, 575, 513, 524, 906, 906, 907, 518, 749, 750, - 13, 14, 221, 221, 428, 428, 560, 619, 624, 476, - 578, 559, 342, 381, 416, 466, 644, 377, 152, 100, - 585, 648, 653, 688, 981, 144, 825, 559, 274, 531, - 654, 274, 514, 620, 40, 274, 620, 274, 514, 645, - 274, 198, 652, 191, 560, 614, 692, 566, 152, 171, - 670, 666, 565, 516, 952, 942, 945, 945, 952, 515, - 518, 13, 678, 684, 4, 948, 4, 948, 562, 566, - 577, 584, 55, 102, 123, 141, 145, 167, 170, 186, - 279, 287, 309, 336, 581, 718, 40, 515, 860, 515, - 171, 518, 515, 317, 912, 515, 861, 861, 11, 15, - 16, 19, 20, 21, 198, 221, 291, 501, 502, 503, - 505, 506, 507, 508, 509, 510, 897, 861, 515, 814, - 815, 868, 166, 171, 915, 916, 518, 515, 40, 917, - 904, 917, 917, 171, 515, 40, 806, 514, 943, 4, - 9, 560, 759, 761, 762, 933, 931, 177, 240, 416, - 420, 422, 448, 559, 742, 473, 818, 795, 224, 795, - 289, 454, 811, 795, 224, 933, 795, 281, 281, 514, - 795, 561, 819, 820, 514, 561, 819, 518, 515, 518, - 516, 514, 828, 514, 514, 516, 39, 827, 514, 847, - 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, - 858, 859, 515, 518, 831, 567, 659, 695, 722, 725, - 959, 975, 904, 905, 514, 472, 920, 921, 860, 905, - 948, 860, 890, 891, 892, 893, 843, 843, 8, 15, - 16, 19, 20, 21, 501, 502, 503, 505, 506, 507, - 508, 509, 510, 560, 895, 900, 515, 904, 426, 426, - 948, 948, 514, 560, 352, 940, 166, 513, 515, 518, - 524, 518, 523, 507, 564, 904, 948, 860, 859, 859, - 825, 860, 860, 860, 860, 860, 860, 860, 860, 5, - 566, 956, 426, 45, 413, 930, 952, 860, 860, 514, - 726, 918, 132, 159, 274, 279, 284, 435, 446, 860, - 279, 514, 860, 428, 53, 176, 193, 198, 236, 391, - 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, - 30, 38, 396, 894, 512, 516, 928, 180, 162, 872, - 365, 514, 886, 934, 171, 792, 906, 792, 514, 562, - 560, 559, 962, 548, 559, 860, 518, 515, 249, 274, - 740, 454, 662, 559, 697, 514, 560, 702, 712, 713, - 715, 41, 126, 753, 518, 454, 753, 265, 728, 365, - 366, 505, 506, 768, 770, 862, 389, 226, 290, 312, - 312, 518, 509, 4, 769, 948, 769, 365, 366, 770, - 559, 941, 278, 393, 789, 514, 943, 944, 518, 180, - 454, 198, 180, 219, 784, 756, 515, 350, 545, 514, - 191, 612, 945, 226, 274, 226, 454, 514, 605, 824, - 825, 945, 560, 191, 945, 191, 560, 26, 137, 386, - 541, 544, 566, 596, 610, 945, 566, 604, 623, 945, - 542, 945, 350, 386, 531, 545, 533, 952, 945, 533, - 952, 945, 533, 350, 386, 545, 945, 945, 945, 945, - 350, 386, 545, 945, 945, 562, 506, 860, 925, 749, - 749, 749, 462, 907, 192, 355, 748, 860, 860, 279, - 557, 562, 279, 557, 560, 333, 574, 515, 518, 287, - 171, 428, 569, 647, 466, 559, 559, 635, 559, 559, - 650, 559, 294, 631, 514, 726, 514, 152, 152, 236, - 560, 602, 612, 615, 618, 628, 630, 476, 478, 607, - 151, 725, 152, 476, 693, 152, 515, 906, 40, 152, - 3, 514, 274, 289, 560, 3, 667, 565, 667, 289, - 667, 672, 860, 575, 507, 514, 533, 576, 683, 865, - 515, 518, 40, 573, 562, 573, 274, 279, 336, 573, - 59, 573, 825, 515, 860, 860, 860, 915, 825, 861, - 861, 861, 861, 861, 861, 132, 274, 284, 861, 861, - 861, 861, 861, 861, 861, 861, 861, 861, 515, 518, - 40, 816, 860, 860, 916, 915, 825, 515, 515, 515, - 904, 825, 943, 515, 312, 509, 312, 366, 509, 514, - 514, 741, 420, 422, 420, 422, 559, 743, 743, 743, - 860, 180, 772, 811, 795, 860, 514, 795, 166, 514, - 561, 802, 811, 825, 515, 518, 819, 515, 972, 3, - 908, 39, 827, 560, 822, 822, 3, 512, 512, 948, - 428, 428, 428, 428, 825, 515, 513, 904, 860, 139, - 921, 922, 515, 515, 515, 524, 518, 523, 516, 515, - 515, 497, 497, 515, 515, 943, 514, 860, 937, 560, - 860, 860, 887, 936, 515, 515, 515, 497, 861, 861, - 145, 904, 171, 132, 159, 279, 284, 435, 446, 514, - 145, 900, 860, 413, 930, 860, 918, 860, 428, 514, - 726, 860, 925, 565, 514, 514, 155, 873, 793, 794, - 818, 749, 818, 948, 859, 954, 954, 249, 514, 794, - 473, 661, 40, 59, 698, 708, 715, 926, 518, 792, - 503, 499, 754, 752, 291, 895, 898, 754, 4, 948, - 770, 290, 451, 767, 518, 243, 943, 734, 59, 933, - 514, 561, 59, 265, 428, 860, 274, 627, 514, 152, - 514, 605, 202, 624, 625, 586, 40, 175, 595, 621, - 586, 26, 137, 354, 356, 386, 538, 539, 540, 546, - 547, 152, 667, 152, 667, 596, 610, 596, 515, 518, - 562, 589, 503, 516, 515, 518, 428, 370, 93, 428, - 724, 370, 428, 428, 428, 370, 552, 524, 513, 524, - 748, 748, 748, 907, 281, 281, 515, 514, 568, 3, - 403, 404, 562, 583, 619, 574, 559, 654, 514, 40, - 620, 645, 652, 647, 352, 416, 562, 656, 657, 624, - 559, 559, 635, 559, 515, 518, 287, 600, 287, 289, - 599, 945, 476, 634, 559, 600, 40, 559, 515, 416, - 860, 650, 584, 152, 559, 670, 952, 571, 582, 683, - 577, 562, 562, 279, 624, 507, 624, 562, 507, 624, - 562, 515, 515, 916, 171, 132, 284, 514, 817, 814, - 514, 515, 515, 515, 560, 759, 818, 743, 743, 743, - 743, 559, 559, 559, 59, 185, 781, 811, 943, 514, - 799, 800, 801, 863, 946, 943, 166, 80, 821, 820, - 515, 515, 512, 825, 515, 518, 515, 948, 513, 948, - 515, 848, 850, 851, 852, 851, 852, 852, 515, 424, - 860, 143, 860, 890, 900, 846, 846, 515, 860, 937, - 938, 939, 40, 198, 515, 940, 859, 860, 36, 36, - 860, 515, 860, 171, 514, 908, 860, 515, 145, 861, - 861, 145, 145, 860, 860, 513, 524, 514, 927, 750, - 473, 860, 300, 877, 518, 772, 748, 772, 515, 722, - 860, 358, 706, 560, 265, 320, 117, 303, 514, 696, - 725, 515, 518, 702, 661, 860, 163, 230, 514, 754, - 290, 559, 515, 944, 180, 726, 727, 933, 944, 945, - 945, 515, 152, 625, 612, 625, 586, 614, 518, 515, - 119, 206, 272, 274, 611, 514, 33, 59, 632, 621, - 74, 80, 93, 117, 119, 206, 274, 279, 328, 344, - 445, 454, 591, 592, 606, 175, 117, 190, 274, 600, - 532, 107, 117, 175, 274, 402, 405, 534, 600, 386, - 540, 439, 945, 560, 544, 3, 37, 42, 49, 55, - 81, 83, 89, 101, 170, 172, 175, 176, 193, 208, - 221, 222, 224, 234, 236, 246, 268, 273, 277, 291, - 299, 301, 321, 361, 380, 387, 391, 409, 418, 438, - 444, 464, 505, 506, 533, 562, 587, 626, 636, 642, - 825, 898, 949, 566, 623, 945, 945, 945, 945, 945, - 945, 945, 945, 945, 945, 575, 925, 925, 515, 515, - 515, 749, 107, 370, 516, 532, 583, 514, 618, 725, - 693, 40, 514, 631, 191, 559, 515, 518, 515, 654, - 514, 40, 609, 607, 615, 86, 674, 107, 272, 620, - 725, 645, 725, 652, 515, 614, 454, 690, 667, 515, - 518, 624, 861, 171, 514, 908, 819, 515, 518, 515, - 772, 559, 559, 559, 559, 30, 103, 181, 364, 514, - 773, 774, 775, 776, 777, 778, 779, 860, 860, 475, - 874, 515, 862, 901, 902, 198, 180, 796, 800, 514, - 515, 802, 803, 804, 952, 827, 948, 827, 560, 827, - 513, 513, 860, 518, 515, 560, 860, 862, 860, 860, - 860, 908, 515, 860, 36, 36, 860, 860, 145, 515, - 506, 925, 515, 906, 515, 860, 515, 514, 560, 878, - 781, 515, 781, 562, 515, 932, 460, 415, 453, 707, - 560, 701, 711, 289, 704, 503, 715, 706, 900, 59, - 515, 515, 459, 460, 731, 586, 612, 515, 515, 476, - 617, 120, 194, 204, 119, 456, 860, 117, 40, 514, - 952, 945, 861, 120, 194, 119, 279, 226, 559, 617, - 88, 632, 191, 279, 533, 860, 632, 279, 505, 506, - 536, 560, 825, 667, 667, 3, 246, 409, 949, 953, - 503, 428, 428, 513, 513, 748, 515, 515, 560, 575, - 454, 570, 572, 624, 515, 634, 40, 416, 860, 584, - 416, 274, 514, 562, 693, 618, 151, 725, 149, 200, - 599, 122, 137, 327, 634, 107, 693, 476, 982, 40, - 514, 289, 560, 689, 514, 582, 861, 908, 515, 515, - 9, 351, 765, 781, 514, 388, 514, 515, 518, 560, - 875, 876, 335, 782, 518, 515, 514, 561, 59, 515, - 906, 198, 515, 803, 513, 825, 937, 513, 191, 515, - 860, 860, 860, 524, 513, 524, 515, 515, 560, 879, - 874, 562, 874, 518, 459, 926, 515, 518, 91, 706, - 860, 515, 944, 944, 344, 617, 514, 608, 586, 515, - 190, 514, 860, 274, 592, 617, 620, 945, 40, 152, - 821, 953, 509, 587, 945, 945, 515, 532, 124, 515, - 607, 725, 725, 515, 559, 152, 40, 515, 945, 634, - 30, 85, 94, 118, 190, 203, 402, 405, 603, 603, - 366, 366, 40, 64, 74, 240, 416, 860, 584, 559, - 514, 560, 705, 714, 868, 515, 515, 514, 874, 904, - 514, 904, 775, 40, 518, 860, 454, 760, 862, 933, - 943, 807, 749, 514, 807, 860, 925, 925, 309, 880, - 782, 782, 725, 303, 725, 701, 289, 514, 699, 559, - 586, 566, 613, 616, 406, 468, 593, 594, 514, 588, - 860, 515, 248, 629, 190, 454, 543, 509, 439, 575, - 562, 693, 599, 982, 514, 559, 725, 607, 674, 725, - 74, 292, 74, 725, 515, 690, 860, 80, 709, 515, - 518, 709, 9, 782, 515, 774, 515, 878, 876, 368, - 515, 748, 933, 513, 513, 513, 59, 749, 760, 760, - 707, 93, 714, 133, 620, 503, 515, 518, 531, 515, - 272, 601, 172, 308, 392, 289, 597, 598, 622, 588, - 860, 439, 40, 514, 982, 599, 634, 982, 292, 292, - 514, 515, 952, 710, 952, 693, 705, 710, 515, 760, - 515, 762, 515, 515, 903, 183, 337, 366, 881, 459, - 945, 515, 275, 451, 629, 587, 616, 515, 594, 204, - 122, 451, 289, 622, 289, 597, 725, 714, 709, 753, - 818, 753, 53, 104, 441, 860, 882, 883, 882, 882, - 515, 725, 818, 386, 598, 63, 272, 357, 386, 590, - 590, 982, 515, 710, 754, 754, 883, 365, 165, 323, - 165, 323, 148, 884, 884, 884, 713, 586, 25, 117, - 279, 693, 753, 36, 104, 180, 272, 425, 818, 818, - 754, 883, 365, 297 -}; - -/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ -static const yytype_int16 yyr1[] = -{ - 0, 525, 526, 527, 527, 528, 528, 528, 528, 528, - 528, 528, 528, 528, 528, 528, 528, 528, 528, 528, - 528, 528, 528, 528, 528, 528, 528, 528, 528, 528, - 528, 528, 528, 528, 528, 528, 528, 528, 528, 528, - 528, 528, 528, 528, 528, 528, 537, 537, 537, 537, - 537, 537, 537, 537, 538, 538, 539, 539, 540, 540, - 540, 540, 541, 541, 542, 542, 542, 542, 542, 542, - 542, 542, 542, 542, 542, 542, 542, 542, 542, 542, - 542, 542, 542, 542, 542, 542, 542, 542, 542, 542, - 542, 542, 542, 543, 543, 544, 544, 544, 544, 545, - 545, 546, 547, 547, 547, 658, 658, 658, 658, 559, - 559, 560, 560, 560, 561, 561, 562, 563, 563, 564, - 565, 566, 566, 566, 566, 723, 723, 723, 723, 723, - 723, 723, 723, 723, 723, 723, 723, 723, 724, 724, - 695, 696, 696, 696, 696, 696, 697, 697, 698, 698, - 698, 699, 699, 699, 700, 700, 701, 702, 702, 703, - 703, 703, 704, 704, 704, 705, 705, 705, 706, 706, - 707, 707, 708, 708, 709, 709, 710, 710, 711, 711, - 712, 712, 713, 713, 714, 714, 715, 655, 655, 655, - 656, 656, 657, 657, 719, 719, 719, 653, 653, 653, - 654, 654, 649, 649, 649, 650, 650, 651, 651, 651, - 652, 652, 671, 671, 671, 672, 672, 673, 673, 674, - 674, 530, 530, 531, 531, 532, 532, 532, 533, 533, - 533, 533, 534, 534, 534, 534, 534, 534, 534, 534, - 534, 534, 534, 534, 534, 534, 535, 535, 536, 536, - 536, 669, 669, 670, 670, 957, 957, 957, 957, 957, - 957, 958, 958, 958, 960, 585, 585, 585, 586, 586, - 587, 587, 587, 587, 587, 587, 588, 588, 589, 590, - 590, 590, 590, 590, 591, 591, 591, 591, 592, 592, - 592, 592, 592, 592, 592, 592, 593, 593, 594, 594, - 595, 595, 595, 596, 597, 598, 598, 598, 598, 598, - 599, 599, 599, 599, 600, 601, 601, 602, 602, 603, - 603, 603, 603, 603, 603, 603, 603, 604, 604, 605, - 606, 606, 606, 606, 607, 607, 607, 607, 608, 609, - 609, 609, 610, 611, 611, 611, 611, 611, 611, 612, - 612, 613, 613, 614, 615, 615, 615, 616, 616, 617, - 617, 618, 618, 618, 619, 620, 620, 621, 621, 622, - 623, 623, 623, 623, 624, 624, 625, 625, 626, 626, - 626, 627, 627, 627, 627, 627, 627, 628, 628, 629, - 629, 629, 629, 630, 631, 631, 631, 631, 631, 631, - 631, 631, 632, 632, 663, 663, 663, 663, 663, 663, - 664, 664, 664, 664, 664, 664, 664, 664, 664, 664, - 664, 664, 664, 664, 664, 664, 664, 664, 665, 665, - 665, 665, 665, 665, 666, 666, 667, 667, 667, 668, - 668, 668, 643, 643, 643, 643, 643, 643, 644, 644, - 645, 645, 959, 567, 567, 567, 568, 568, 568, 569, - 569, 570, 570, 571, 571, 572, 572, 573, 573, 574, - 574, 575, 575, 576, 576, 576, 576, 576, 576, 577, - 578, 578, 579, 579, 580, 580, 581, 581, 581, 581, - 581, 581, 581, 581, 581, 581, 581, 581, 581, 581, - 581, 581, 582, 583, 583, 583, 583, 583, 584, 584, - 725, 725, 726, 726, 726, 727, 727, 727, 727, 727, - 727, 727, 727, 728, 728, 729, 729, 730, 730, 730, - 730, 730, 730, 730, 730, 730, 730, 730, 730, 730, - 730, 730, 730, 730, 730, 730, 731, 731, 732, 732, - 733, 733, 734, 734, 734, 735, 735, 736, 736, 737, - 737, 737, 738, 738, 739, 740, 740, 740, 741, 741, - 742, 742, 742, 742, 742, 742, 742, 742, 742, 743, - 743, 744, 744, 744, 745, 746, 746, 747, 747, 748, - 748, 748, 749, 749, 750, 750, 751, 751, 752, 752, - 753, 753, 753, 754, 754, 754, 755, 755, 755, 755, - 756, 756, 757, 757, 757, 757, 758, 758, 759, 759, - 759, 759, 759, 759, 760, 760, 761, 761, 762, 762, - 762, 762, 763, 764, 764, 765, 765, 766, 766, 766, - 766, 766, 767, 768, 768, 768, 769, 769, 770, 770, - 771, 771, 772, 772, 772, 773, 773, 774, 774, 775, - 775, 775, 775, 775, 776, 777, 778, 779, 780, 780, - 781, 781, 782, 782, 783, 783, 784, 784, 785, 785, - 786, 787, 787, 787, 787, 788, 788, 789, 789, 789, - 790, 790, 791, 791, 792, 792, 793, 793, 794, 794, - 795, 795, 795, 795, 795, 795, 795, 795, 795, 795, - 796, 796, 797, 797, 797, 798, 798, 799, 799, 800, - 800, 801, 801, 802, 802, 803, 804, 804, 805, 805, - 805, 805, 805, 805, 805, 805, 805, 805, 805, 806, - 806, 806, 806, 807, 807, 808, 808, 808, 808, 808, - 809, 809, 809, 809, 809, 809, 810, 810, 811, 811, - 812, 812, 812, 812, 813, 813, 814, 815, 815, 816, - 816, 817, 817, 818, 818, 819, 819, 820, 821, 821, - 822, 822, 823, 823, 824, 824, 825, 825, 825, 825, - 825, 825, 825, 825, 825, 825, 826, 826, 827, 827, - 827, 828, 828, 828, 828, 828, 828, 828, 829, 829, - 829, 829, 830, 831, 831, 832, 832, 832, 832, 832, - 832, 832, 832, 832, 832, 832, 833, 833, 834, 834, - 835, 835, 836, 837, 838, 838, 839, 839, 840, 841, - 842, 842, 842, 842, 842, 842, 843, 843, 844, 844, - 844, 844, 845, 846, 846, 846, 847, 847, 848, 848, - 849, 849, 850, 850, 851, 851, 852, 852, 853, 853, - 854, 854, 855, 855, 856, 856, 857, 857, 858, 858, - 859, 859, 859, 859, 859, 859, 859, 859, 859, 859, - 859, 859, 859, 859, 859, 859, 859, 859, 859, 859, - 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, - 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, - 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, - 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, - 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, - 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, - 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, - 861, 861, 861, 861, 861, 861, 861, 861, 861, 861, - 861, 861, 861, 861, 861, 861, 861, 861, 861, 861, - 861, 861, 861, 861, 861, 862, 862, 862, 863, 863, - 863, 863, 863, 863, 863, 863, 863, 863, 863, 863, - 863, 864, 864, 864, 864, 864, 864, 865, 866, 866, - 866, 866, 866, 866, 867, 867, 868, 868, 869, 869, - 869, 869, 869, 869, 869, 869, 869, 869, 869, 869, - 869, 869, 870, 870, 871, 871, 872, 872, 872, 873, - 873, 874, 874, 875, 875, 876, 877, 877, 877, 878, - 879, 879, 880, 880, 881, 881, 881, 881, 882, 882, - 883, 883, 883, 883, 883, 884, 884, 884, 884, 884, - 885, 885, 886, 886, 887, 888, 888, 889, 889, 890, - 891, 891, 892, 892, 893, 893, 894, 894, 894, 895, - 895, 896, 896, 896, 896, 896, 896, 896, 896, 896, - 896, 896, 896, 896, 896, 897, 897, 898, 898, 899, - 899, 899, 899, 899, 899, 899, 899, 900, 900, 901, - 901, 902, 902, 903, 903, 904, 904, 905, 905, 906, - 906, 907, 907, 907, 908, 908, 909, 909, 910, 910, - 910, 910, 910, 910, 910, 910, 910, 910, 910, 910, - 910, 910, 911, 911, 912, 913, 913, 914, 914, 914, - 914, 914, 914, 915, 916, 917, 917, 917, 918, 918, - 919, 920, 920, 921, 922, 922, 923, 923, 924, 924, - 564, 564, 564, 564, 925, 925, 926, 926, 927, 927, - 927, 928, 928, 928, 928, 928, 929, 929, 930, 930, - 931, 931, 932, 932, 933, 933, 934, 934, 934, 935, - 935, 936, 936, 937, 938, 938, 939, 939, 940, 940, - 940, 941, 941, 942, 942, 943, 943, 944, 944, 945, - 946, 946, 947, 947, 947, 947, 947, 947, 947, 947, - 947, 947, 947, 947, 947, 947, 948, 949, 949, 949, - 950, 950, 950, 951, 951, 951, 952, 952, 953, 953, - 954, 954, 955, 956, 956, 720, 721, 721, 722, 722, - 722, 722, 722, 722, 646, 646, 646, 647, 647, 648, - 648, 648, 648, 688, 688, 689, 690, 690, 691, 691, - 692, 692, 693, 693, 694, 694, 529, 529, 529, 529, - 529, 529, 554, 554, 555, 555, 556, 556, 557, 557, - 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, - 686, 686, 687, 675, 675, 675, 675, 676, 676, 677, - 677, 677, 678, 678, 678, 678, 678, 678, 678, 678, - 678, 678, 678, 678, 678, 678, 678, 678, 678, 678, - 678, 678, 678, 678, 678, 678, 678, 678, 678, 678, - 678, 678, 679, 679, 679, 680, 680, 681, 681, 682, - 682, 683, 683, 683, 683, 684, 685, 685, 969, 969, - 969, 969, 970, 970, 970, 970, 971, 971, 972, 973, - 973, 973, 973, 973, 973, 973, 974, 974, 716, 716, - 716, 716, 716, 717, 717, 718, 718, 961, 961, 961, - 961, 961, 962, 962, 962, 962, 962, 963, 963, 964, - 964, 965, 965, 659, 659, 660, 660, 660, 661, 661, - 662, 662, 548, 548, 549, 549, 550, 550, 550, 551, - 551, 552, 552, 966, 966, 966, 966, 967, 967, 968, - 968, 968, 975, 975, 975, 975, 975, 975, 975, 975, - 976, 976, 977, 977, 978, 978, 979, 979, 980, 980, - 553, 981, 981, 981, 981, 981, 982, 982, 982, 982, - 633, 633, 633, 634, 634, 634, 635, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 636, 636, 636, - 636, 636, 636, 636, 636, 636, 636, 637, 637, 637, - 637, 637, 637, 637, 637, 637, 637, 637, 637, 637, - 637, 637, 637, 637, 637, 637, 637, 637, 637, 637, - 637, 637, 637, 637, 637, 637, 637, 637, 637, 637, - 637, 637, 637, 637, 637, 637, 637, 637, 637, 637, - 637, 637, 637, 637, 637, 637, 637, 637, 637, 637, - 637, 638, 638, 638, 638, 638, 638, 638, 638, 638, - 638, 638, 638, 638, 638, 638, 638, 638, 638, 638, - 638, 638, 638, 638, 638, 638, 638, 638, 638, 639, - 639, 639, 639, 639, 639, 639, 639, 639, 639, 639, - 639, 639, 639, 639, 639, 639, 639, 639, 639, 639, - 639, 639, 639, 639, 639, 639, 639, 639, 640, 640, - 640, 640, 640, 640, 640, 640, 640, 640, 640, 640, - 640, 640, 640, 640, 640, 640, 640, 640, 640, 640, - 640, 640, 640, 640, 640, 640, 640, 640, 640, 640, - 640, 640, 640, 640, 640, 640, 640, 640, 640, 640, - 640, 640, 640, 640, 640, 640, 640, 640, 640, 640, - 640, 640, 640, 640, 640, 640, 640, 640, 640, 640, - 640, 640, 640, 640, 640, 640, 640, 640, 640, 640, - 640, 640, 640, 640, 640, 640, 640, 640, 640, 641, - 641, 641, 641, 641, 641, 641, 641, 641, 641, 641, - 641, 641, 641, 641, 641, 641, 641, 641, 641, 641, - 641, 641, 641, 641, 641, 641, 641, 641, 641, 641, - 641, 642, 642, 642, 642, 642, 642, 642, 642, 642, - 642, 642, 642, 642, 642, 642, 642, 642, 642, 642, - 642, 642, 642, 642, 642, 642, 642, 642, 642, 642, - 642, 642, 642, 642, 642, 642, 642, 642, 642, 642, - 642, 642, 642, 642, 642, 642, 642, 642, 642, 642, - 642, 642, 642, 642, 642, 642, 642, 642, 642, 642, - 642, 642, 642, 642, 642, 642, 642, 642, 642, 642, - 642, 642, 642, 642, 642, 642 -}; - -/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ -static const yytype_int8 yyr2[] = -{ - 0, 2, 1, 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, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 0, 4, 6, 4, 6, - 4, 6, 4, 6, 1, 2, 3, 2, 1, 3, - 2, 3, 1, 3, 2, 5, 3, 6, 4, 6, - 6, 6, 5, 5, 6, 9, 4, 5, 7, 6, - 4, 8, 4, 2, 4, 3, 6, 4, 2, 2, - 2, 2, 1, 2, 0, 1, 2, 2, 2, 1, - 3, 4, 2, 1, 0, 2, 3, 2, 3, 1, - 2, 1, 1, 1, 1, 1, 1, 1, 2, 2, - 1, 1, 1, 1, 1, 6, 6, 8, 6, 8, - 6, 8, 6, 8, 8, 10, 8, 10, 1, 0, - 9, 1, 4, 4, 7, 2, 1, 3, 2, 2, - 0, 4, 3, 0, 1, 0, 2, 3, 5, 2, - 2, 0, 8, 5, 0, 5, 5, 7, 2, 0, - 1, 1, 1, 3, 2, 0, 1, 0, 1, 3, - 1, 3, 1, 2, 1, 3, 2, 6, 8, 5, - 1, 0, 1, 3, 2, 4, 5, 5, 8, 7, - 1, 0, 8, 11, 10, 0, 1, 0, 1, 1, - 0, 2, 3, 9, 12, 1, 3, 1, 3, 3, - 0, 4, 6, 1, 2, 1, 1, 0, 1, 2, - 2, 1, 2, 2, 1, 2, 3, 2, 2, 2, - 2, 3, 3, 3, 1, 3, 1, 0, 1, 2, - 2, 5, 7, 0, 2, 2, 2, 2, 2, 2, - 2, 1, 1, 0, 2, 9, 12, 11, 0, 2, - 1, 1, 1, 1, 1, 1, 3, 0, 1, 2, - 1, 1, 2, 2, 3, 1, 1, 2, 2, 1, - 2, 3, 5, 3, 2, 5, 1, 1, 1, 0, - 5, 7, 5, 2, 3, 1, 1, 2, 2, 0, - 3, 4, 4, 0, 3, 2, 0, 3, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, - 1, 2, 2, 2, 2, 2, 2, 0, 3, 3, - 3, 0, 1, 2, 1, 2, 2, 2, 2, 3, - 4, 1, 3, 1, 1, 1, 1, 3, 1, 2, - 0, 1, 2, 0, 1, 3, 0, 2, 0, 3, - 3, 1, 5, 3, 1, 3, 1, 2, 1, 4, - 5, 5, 6, 3, 7, 4, 11, 1, 3, 2, - 2, 2, 0, 3, 1, 1, 2, 2, 2, 2, - 1, 0, 1, 2, 6, 4, 6, 4, 6, 8, - 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, - 1, 1, 1, 3, 3, 3, 3, 1, 2, 2, - 1, 3, 1, 1, 1, 3, 1, 1, 0, 1, - 1, 1, 8, 11, 10, 7, 10, 9, 1, 1, - 2, 3, 8, 11, 9, 7, 0, 3, 3, 1, - 1, 3, 0, 1, 3, 1, 0, 1, 0, 1, - 0, 1, 3, 1, 1, 1, 3, 1, 0, 2, - 2, 0, 2, 0, 1, 0, 1, 1, 1, 3, - 3, 1, 1, 3, 3, 3, 3, 3, 3, 4, - 3, 2, 1, 1, 1, 1, 3, 1, 1, 3, - 1, 1, 3, 3, 3, 1, 2, 4, 4, 2, - 3, 5, 5, 1, 1, 3, 0, 11, 11, 10, - 12, 1, 2, 5, 4, 4, 4, 4, 7, 5, - 4, 7, 6, 9, 9, 4, 1, 1, 1, 1, - 1, 1, 1, 5, 1, 1, 3, 1, 2, 2, - 2, 3, 1, 3, 7, 1, 2, 0, 2, 0, - 3, 3, 4, 4, 4, 4, 3, 2, 1, 1, - 0, 1, 1, 0, 2, 1, 5, 1, 0, 2, - 2, 0, 1, 0, 3, 5, 1, 3, 4, 3, - 1, 1, 0, 2, 2, 0, 2, 2, 1, 1, - 1, 0, 2, 4, 5, 4, 2, 3, 2, 2, - 2, 2, 1, 2, 3, 0, 1, 0, 5, 1, - 4, 6, 2, 1, 0, 4, 0, 1, 1, 2, - 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, - 1, 1, 3, 3, 0, 1, 3, 1, 2, 1, - 1, 1, 1, 1, 2, 4, 4, 5, 1, 1, - 2, 0, 2, 0, 1, 3, 1, 0, 1, 2, - 3, 2, 4, 2, 3, 2, 0, 1, 2, 0, - 4, 5, 1, 2, 2, 0, 1, 3, 1, 2, - 3, 3, 3, 3, 3, 3, 1, 4, 9, 9, - 3, 0, 2, 2, 0, 5, 3, 1, 3, 5, - 3, 1, 2, 1, 3, 5, 1, 2, 3, 4, - 5, 4, 5, 4, 6, 5, 4, 5, 5, 5, - 2, 4, 1, 1, 0, 1, 4, 5, 4, 0, - 2, 2, 2, 1, 1, 1, 1, 0, 4, 2, - 1, 2, 2, 4, 2, 6, 2, 1, 3, 4, - 0, 2, 0, 2, 0, 1, 3, 3, 2, 0, - 2, 4, 1, 1, 1, 0, 2, 3, 5, 6, - 2, 3, 1, 5, 5, 5, 3, 3, 3, 4, - 0, 1, 1, 1, 1, 1, 2, 4, 1, 1, - 1, 1, 2, 3, 0, 1, 1, 1, 1, 1, - 2, 2, 2, 2, 2, 1, 3, 0, 1, 1, - 1, 1, 5, 2, 1, 1, 1, 1, 4, 1, - 2, 2, 1, 3, 3, 2, 1, 0, 5, 2, - 5, 2, 1, 3, 3, 0, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 3, 3, 3, 3, 3, 3, 3, 0, - 1, 3, 3, 5, 2, 2, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 2, 2, 3, 3, 2, 2, 3, 3, 5, - 4, 6, 3, 5, 4, 6, 4, 6, 5, 7, - 3, 2, 4, 3, 2, 3, 3, 3, 3, 4, - 3, 4, 3, 4, 5, 6, 6, 7, 6, 7, - 6, 7, 3, 4, 4, 6, 1, 4, 3, 5, - 1, 3, 2, 2, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, - 2, 5, 6, 6, 7, 1, 1, 2, 1, 1, - 2, 2, 3, 1, 2, 4, 1, 1, 2, 2, - 4, 1, 1, 3, 1, 4, 1, 3, 3, 6, - 7, 9, 7, 7, 5, 1, 1, 1, 5, 6, - 6, 4, 4, 4, 4, 6, 5, 5, 5, 4, - 6, 4, 7, 9, 5, 0, 5, 4, 0, 1, - 0, 2, 0, 1, 3, 3, 2, 2, 0, 6, - 1, 0, 3, 0, 3, 3, 3, 0, 1, 4, - 2, 2, 2, 2, 2, 3, 2, 2, 3, 0, - 4, 3, 1, 5, 3, 1, 3, 1, 2, 3, - 1, 3, 1, 2, 1, 0, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 4, 1, 4, 1, - 4, 1, 2, 1, 2, 1, 2, 1, 3, 1, - 3, 1, 2, 1, 3, 1, 2, 1, 0, 1, - 3, 1, 3, 3, 1, 3, 3, 0, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 4, 3, 2, 3, 0, 3, 3, 2, - 2, 1, 0, 2, 2, 3, 2, 1, 1, 3, - 5, 1, 2, 4, 2, 0, 1, 0, 1, 2, - 3, 5, 7, 7, 1, 0, 0, 2, 0, 2, - 3, 3, 3, 5, 7, 7, 0, 2, 1, 0, - 1, 0, 1, 3, 1, 2, 3, 2, 1, 4, - 2, 1, 0, 3, 1, 3, 1, 2, 4, 2, - 0, 1, 3, 1, 3, 1, 2, 1, 3, 1, - 1, 2, 1, 1, 2, 1, 1, 2, 7, 2, - 5, 3, 3, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, - 3, 0, 1, 1, 1, 5, 3, 0, 1, 1, - 1, 1, 1, 1, 4, 7, 6, 2, 0, 1, - 1, 1, 1, 13, 16, 1, 2, 0, 1, 0, - 1, 0, 2, 0, 1, 0, 6, 8, 6, 8, - 6, 8, 3, 2, 1, 0, 6, 6, 1, 1, - 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, - 4, 6, 3, 2, 4, 3, 5, 1, 0, 1, - 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, - 1, 1, 1, 1, 1, 2, 1, 1, 2, 3, - 3, 3, 1, 3, 3, 2, 3, 3, 1, 1, - 1, 3, 5, 1, 1, 1, 1, 3, 2, 2, - 3, 4, 5, 1, 1, 1, 1, 4, 6, 5, - 4, 6, 1, 1, 1, 1, 1, 1, 0, 1, - 3, 1, 0, 7, 3, 1, 2, 3, 2, 0, - 2, 0, 2, 4, 5, 8, 2, 3, 5, 1, - 0, 2, 0, 2, 3, 3, 3, 1, 1, 1, - 2, 3, 2, 2, 2, 2, 3, 4, 3, 1, - 1, 1, 1, 1, 1, 0, 1, 3, 1, 3, - 2, 9, 12, 11, 12, 14, 3, 4, 4, 0, - 7, 10, 9, 2, 3, 0, 4, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1 -}; - + 522, 523, 542, 544, 675, 729, 778, 781, 784, 785, + 786, 788, 789, 790, 791, 793, 794, 809, 811, 812, + 813, 814, 815, 816, 817, 819, 820, 835, 836, 847, + 869, 874, 882, 883, 884, 896, 897, 898, 881, 883, + 940, 940, 544, 940, 497, 171, 428, 503, 516, 545, + 761, 954, 3, 170, 172, 464, 935, 949, 951, 170, + 952, 809, 853, 854, 687, 518, 514, 904, 515, 515, + 515, 528, 171, 294, 559, 954, 30, 132, 693, 693, + 59, 693, 161, 166, 237, 286, 704, 706, 707, 732, + 734, 735, 736, 180, 289, 454, 289, 698, 699, 514, + 541, 417, 968, 497, 223, 152, 26, 32, 137, 293, + 350, 354, 386, 457, 534, 537, 538, 350, 152, 40, + 60, 106, 201, 250, 260, 272, 304, 350, 356, 381, + 386, 400, 537, 587, 590, 152, 350, 386, 537, 152, + 350, 386, 537, 152, 40, 961, 809, 875, 547, 548, + 546, 3, 30, 37, 42, 49, 55, 81, 83, 89, + 101, 132, 170, 172, 175, 176, 193, 208, 221, 222, + 224, 234, 236, 246, 268, 277, 299, 301, 321, 361, + 380, 391, 409, 418, 438, 462, 464, 515, 809, 856, + 857, 899, 905, 977, 982, 809, 416, 541, 542, 515, + 514, 633, 370, 580, 644, 274, 911, 40, 191, 542, + 579, 466, 191, 541, 191, 541, 976, 191, 541, 191, + 541, 89, 916, 152, 480, 90, 129, 307, 421, 191, + 542, 152, 516, 903, 63, 357, 518, 650, 152, 518, + 650, 152, 289, 583, 584, 809, 905, 352, 515, 518, + 4, 159, 289, 435, 505, 506, 544, 589, 592, 898, + 930, 932, 933, 936, 931, 428, 514, 664, 668, 171, + 809, 854, 514, 3, 68, 69, 109, 110, 113, 114, + 188, 189, 252, 253, 254, 255, 256, 257, 258, 259, + 262, 263, 375, 376, 470, 471, 494, 495, 544, 796, + 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, + 807, 859, 860, 756, 757, 809, 541, 809, 861, 505, + 506, 542, 810, 811, 836, 847, 863, 514, 809, 853, + 864, 809, 58, 171, 232, 429, 809, 854, 867, 809, + 515, 543, 514, 418, 712, 713, 713, 695, 696, 744, + 219, 690, 224, 37, 224, 380, 758, 224, 299, 759, + 744, 759, 224, 758, 514, 224, 759, 224, 148, 199, + 746, 224, 713, 514, 543, 514, 713, 296, 542, 544, + 947, 809, 942, 944, 856, 3, 37, 42, 49, 54, + 55, 56, 57, 71, 72, 81, 83, 89, 101, 112, + 115, 164, 170, 172, 176, 193, 208, 215, 216, 218, + 221, 222, 224, 234, 236, 246, 267, 268, 269, 277, + 282, 299, 301, 321, 339, 361, 365, 380, 387, 391, + 394, 409, 418, 426, 427, 438, 444, 461, 464, 772, + 774, 775, 777, 779, 781, 783, 785, 786, 787, 789, + 790, 793, 794, 858, 901, 977, 980, 40, 235, 542, + 514, 512, 675, 463, 792, 809, 873, 792, 792, 514, + 514, 780, 780, 324, 675, 514, 782, 520, 71, 72, + 792, 809, 780, 514, 514, 478, 500, 514, 795, 514, + 795, 809, 809, 809, 148, 885, 886, 809, 854, 855, + 675, 809, 853, 543, 837, 838, 839, 9, 548, 516, + 545, 876, 545, 514, 544, 514, 514, 544, 898, 3, + 8, 11, 15, 16, 17, 18, 19, 20, 21, 36, + 40, 46, 53, 80, 176, 193, 198, 221, 222, 236, + 274, 277, 291, 294, 391, 498, 501, 502, 503, 505, + 506, 507, 508, 509, 510, 845, 846, 847, 849, 879, + 477, 821, 301, 809, 518, 690, 514, 544, 690, 3, + 117, 240, 544, 589, 794, 943, 104, 944, 944, 542, + 40, 542, 515, 518, 929, 518, 515, 688, 892, 893, + 40, 954, 192, 352, 219, 386, 677, 677, 30, 700, + 701, 809, 59, 677, 694, 163, 271, 720, 226, 272, + 338, 389, 451, 4, 9, 30, 715, 809, 505, 506, + 716, 717, 809, 811, 732, 733, 707, 706, 704, 705, + 166, 735, 284, 737, 59, 683, 684, 685, 747, 810, + 883, 883, 704, 732, 854, 904, 235, 541, 74, 82, + 93, 168, 191, 328, 445, 542, 615, 625, 640, 82, + 93, 550, 93, 550, 514, 428, 514, 613, 244, 448, + 613, 93, 518, 428, 541, 3, 777, 589, 59, 591, + 589, 589, 106, 250, 260, 59, 428, 476, 500, 588, + 265, 370, 588, 590, 761, 93, 428, 550, 370, 541, + 428, 370, 960, 542, 664, 513, 524, 856, 856, 857, + 518, 698, 699, 13, 14, 221, 221, 428, 428, 542, + 632, 637, 476, 667, 541, 377, 342, 381, 416, 466, + 653, 152, 100, 576, 598, 912, 913, 972, 144, 774, + 274, 198, 581, 541, 274, 577, 587, 274, 514, 633, + 40, 274, 633, 274, 514, 654, 191, 542, 627, 917, + 548, 152, 171, 594, 649, 547, 516, 902, 892, 895, + 895, 902, 515, 518, 13, 931, 937, 4, 898, 4, + 898, 544, 548, 666, 673, 55, 102, 123, 141, 145, + 167, 170, 186, 279, 287, 309, 336, 670, 947, 40, + 515, 809, 515, 171, 518, 515, 317, 862, 515, 810, + 810, 11, 15, 16, 19, 20, 21, 198, 221, 291, + 501, 502, 503, 505, 506, 507, 508, 509, 510, 847, + 810, 515, 763, 764, 818, 166, 171, 865, 866, 518, + 515, 40, 867, 854, 867, 867, 171, 515, 40, 755, + 514, 893, 4, 9, 542, 708, 710, 711, 883, 881, + 177, 240, 416, 420, 422, 448, 541, 691, 473, 767, + 744, 744, 224, 744, 289, 454, 760, 744, 224, 883, + 744, 744, 281, 281, 514, 744, 543, 768, 769, 514, + 543, 768, 518, 515, 518, 516, 514, 777, 514, 514, + 516, 39, 776, 514, 796, 797, 798, 799, 800, 801, + 802, 803, 804, 805, 806, 807, 808, 515, 518, 780, + 551, 655, 656, 674, 909, 953, 965, 854, 855, 514, + 472, 870, 871, 809, 855, 898, 809, 840, 841, 842, + 843, 792, 792, 8, 15, 16, 19, 20, 21, 501, + 502, 503, 505, 506, 507, 508, 509, 510, 542, 845, + 850, 515, 854, 426, 426, 898, 898, 514, 542, 352, + 890, 166, 513, 515, 518, 524, 518, 521, 507, 546, + 854, 898, 809, 808, 808, 774, 809, 809, 809, 809, + 809, 809, 809, 809, 5, 548, 906, 426, 45, 413, + 880, 902, 809, 809, 514, 675, 868, 132, 159, 274, + 279, 284, 435, 446, 809, 279, 514, 809, 428, 53, + 176, 193, 198, 236, 391, 809, 809, 809, 809, 809, + 809, 809, 809, 809, 809, 30, 38, 396, 844, 512, + 516, 878, 180, 162, 822, 365, 514, 836, 884, 171, + 741, 856, 741, 514, 544, 542, 541, 949, 541, 957, + 809, 518, 515, 249, 274, 689, 454, 956, 541, 553, + 514, 542, 558, 568, 569, 571, 41, 126, 702, 518, + 454, 702, 265, 677, 365, 366, 505, 506, 717, 719, + 811, 389, 226, 290, 312, 312, 518, 509, 4, 718, + 898, 718, 365, 366, 719, 541, 891, 278, 393, 738, + 514, 893, 894, 518, 180, 454, 198, 180, 219, 733, + 705, 515, 350, 537, 514, 191, 625, 895, 226, 274, + 226, 454, 514, 618, 773, 774, 895, 542, 191, 895, + 191, 542, 26, 137, 386, 533, 536, 548, 609, 623, + 895, 548, 617, 636, 895, 534, 895, 350, 386, 537, + 587, 589, 902, 895, 589, 902, 895, 589, 350, 386, + 537, 895, 895, 895, 895, 350, 386, 537, 895, 895, + 544, 506, 809, 875, 698, 698, 698, 462, 857, 192, + 355, 697, 809, 809, 279, 544, 924, 279, 924, 542, + 333, 663, 515, 518, 287, 171, 428, 658, 911, 579, + 466, 541, 541, 976, 541, 541, 541, 294, 644, 514, + 675, 152, 3, 514, 514, 152, 152, 236, 542, 615, + 625, 628, 631, 641, 643, 476, 478, 620, 151, 674, + 152, 476, 918, 152, 515, 856, 40, 274, 289, 542, + 3, 650, 547, 650, 289, 650, 583, 809, 664, 507, + 514, 589, 665, 815, 936, 515, 518, 40, 662, 544, + 662, 274, 279, 336, 662, 59, 662, 774, 515, 809, + 809, 809, 865, 774, 810, 810, 810, 810, 810, 810, + 132, 274, 284, 810, 810, 810, 810, 810, 810, 810, + 810, 810, 810, 515, 518, 40, 765, 809, 809, 866, + 865, 774, 515, 515, 515, 854, 774, 893, 515, 312, + 509, 312, 366, 509, 514, 514, 690, 420, 422, 420, + 422, 541, 692, 692, 692, 809, 180, 721, 760, 760, + 744, 809, 514, 744, 166, 760, 514, 543, 751, 760, + 774, 515, 518, 768, 515, 942, 3, 858, 39, 776, + 542, 771, 771, 3, 512, 512, 898, 428, 428, 428, + 428, 774, 515, 513, 854, 809, 139, 871, 872, 515, + 515, 515, 524, 518, 521, 516, 515, 515, 497, 497, + 515, 515, 893, 514, 809, 887, 542, 809, 809, 837, + 886, 515, 515, 515, 497, 810, 810, 145, 854, 171, + 132, 159, 279, 284, 435, 446, 514, 145, 850, 809, + 413, 880, 809, 868, 809, 428, 514, 675, 809, 875, + 547, 514, 514, 155, 823, 742, 743, 767, 698, 767, + 898, 808, 904, 904, 249, 514, 743, 473, 955, 40, + 59, 554, 564, 571, 876, 518, 741, 503, 499, 703, + 701, 291, 845, 848, 703, 4, 898, 719, 290, 451, + 716, 518, 243, 893, 683, 59, 883, 514, 543, 59, + 265, 428, 809, 274, 640, 514, 152, 514, 618, 202, + 637, 638, 599, 40, 175, 608, 634, 599, 26, 137, + 354, 356, 386, 530, 531, 532, 538, 539, 152, 650, + 152, 650, 609, 623, 609, 515, 518, 544, 602, 503, + 516, 515, 518, 428, 370, 93, 428, 550, 370, 428, + 428, 428, 370, 961, 524, 513, 524, 697, 697, 697, + 857, 281, 281, 515, 514, 657, 3, 403, 404, 544, + 672, 632, 663, 581, 541, 577, 514, 40, 633, 654, + 911, 352, 416, 544, 573, 574, 579, 673, 637, 541, + 541, 976, 541, 515, 518, 287, 613, 287, 289, 612, + 895, 476, 975, 541, 613, 40, 541, 515, 416, 809, + 152, 541, 594, 902, 660, 671, 936, 666, 544, 544, + 279, 637, 507, 637, 544, 507, 637, 544, 515, 515, + 866, 171, 132, 284, 514, 766, 763, 514, 515, 515, + 515, 542, 708, 767, 692, 692, 692, 692, 541, 541, + 541, 59, 185, 730, 760, 893, 514, 748, 749, 750, + 812, 814, 893, 166, 80, 770, 769, 515, 515, 512, + 774, 515, 518, 515, 898, 513, 898, 515, 797, 799, + 800, 801, 800, 801, 801, 515, 424, 809, 143, 809, + 840, 850, 795, 795, 515, 809, 887, 888, 889, 40, + 198, 515, 890, 808, 809, 36, 36, 809, 515, 809, + 171, 514, 858, 809, 515, 145, 810, 810, 145, 145, + 809, 809, 513, 524, 514, 877, 699, 473, 809, 300, + 827, 518, 721, 697, 721, 515, 909, 809, 358, 562, + 542, 265, 320, 117, 303, 514, 552, 674, 515, 518, + 558, 955, 809, 163, 230, 514, 703, 290, 541, 515, + 894, 180, 675, 676, 883, 894, 895, 895, 515, 152, + 638, 625, 638, 599, 627, 518, 515, 119, 206, 272, + 274, 624, 514, 33, 59, 645, 634, 74, 80, 93, + 117, 119, 206, 274, 279, 328, 344, 445, 454, 604, + 605, 619, 175, 117, 190, 274, 613, 588, 107, 117, + 175, 274, 402, 405, 590, 613, 386, 532, 439, 895, + 542, 536, 3, 37, 42, 49, 55, 81, 83, 89, + 101, 170, 172, 175, 176, 193, 208, 221, 222, 224, + 234, 236, 246, 268, 273, 277, 291, 299, 301, 321, + 361, 380, 387, 391, 409, 418, 438, 444, 464, 505, + 506, 544, 589, 600, 639, 774, 848, 899, 977, 983, + 548, 636, 895, 895, 895, 895, 895, 895, 895, 895, + 895, 895, 664, 875, 875, 515, 515, 515, 698, 107, + 370, 516, 588, 672, 514, 514, 631, 674, 918, 40, + 644, 191, 541, 515, 518, 581, 515, 515, 577, 514, + 40, 622, 620, 628, 86, 585, 107, 272, 633, 674, + 654, 674, 627, 454, 915, 650, 515, 518, 637, 810, + 171, 514, 858, 768, 515, 518, 515, 721, 541, 541, + 541, 541, 30, 103, 181, 364, 514, 722, 723, 724, + 725, 726, 727, 728, 809, 809, 475, 824, 515, 811, + 851, 852, 198, 180, 745, 749, 515, 751, 752, 753, + 902, 776, 898, 776, 542, 776, 513, 513, 809, 518, + 515, 542, 809, 811, 809, 809, 809, 858, 515, 809, + 36, 36, 809, 809, 145, 515, 506, 875, 515, 856, + 515, 809, 515, 514, 542, 828, 730, 515, 730, 544, + 515, 882, 460, 415, 453, 563, 542, 557, 567, 289, + 560, 503, 571, 562, 850, 59, 515, 515, 459, 460, + 680, 599, 625, 515, 515, 476, 630, 120, 194, 204, + 119, 456, 809, 117, 40, 514, 902, 895, 810, 120, + 194, 119, 279, 226, 541, 630, 88, 645, 191, 279, + 589, 809, 645, 279, 505, 506, 592, 542, 774, 650, + 650, 3, 246, 409, 899, 903, 503, 428, 428, 513, + 513, 697, 515, 515, 542, 664, 454, 659, 661, 673, + 637, 515, 975, 40, 416, 809, 416, 274, 514, 544, + 514, 918, 631, 151, 674, 149, 200, 612, 122, 137, + 327, 975, 107, 918, 476, 973, 40, 289, 542, 914, + 514, 671, 810, 858, 515, 515, 9, 351, 714, 730, + 514, 388, 514, 515, 518, 542, 825, 826, 335, 731, + 518, 515, 514, 543, 59, 515, 198, 515, 752, 513, + 774, 887, 513, 191, 515, 809, 809, 809, 524, 513, + 524, 515, 515, 542, 829, 824, 544, 824, 518, 459, + 876, 515, 518, 91, 562, 809, 515, 894, 894, 344, + 630, 514, 621, 599, 515, 190, 514, 809, 274, 605, + 630, 633, 895, 40, 152, 770, 903, 509, 600, 895, + 895, 515, 588, 124, 515, 515, 620, 674, 674, 541, + 152, 673, 40, 515, 895, 975, 30, 85, 94, 118, + 190, 203, 402, 405, 616, 616, 366, 366, 40, 64, + 74, 240, 416, 809, 541, 514, 542, 561, 570, 818, + 515, 515, 514, 824, 854, 514, 854, 724, 40, 518, + 809, 454, 709, 811, 883, 893, 756, 514, 756, 809, + 875, 875, 309, 830, 731, 731, 674, 303, 674, 557, + 289, 514, 555, 541, 599, 548, 626, 629, 406, 468, + 606, 607, 514, 601, 809, 515, 248, 642, 190, 454, + 535, 509, 439, 664, 544, 918, 612, 973, 514, 541, + 515, 674, 620, 585, 674, 74, 292, 74, 674, 915, + 809, 80, 565, 515, 518, 565, 9, 731, 515, 723, + 515, 828, 826, 368, 515, 883, 513, 513, 513, 59, + 698, 709, 709, 563, 93, 570, 133, 633, 503, 515, + 518, 587, 515, 272, 614, 172, 308, 392, 289, 610, + 611, 635, 601, 809, 439, 40, 514, 973, 612, 975, + 973, 292, 292, 514, 515, 902, 566, 902, 918, 561, + 566, 515, 709, 515, 711, 515, 853, 183, 337, 366, + 831, 459, 895, 515, 275, 451, 642, 600, 629, 515, + 607, 204, 122, 451, 289, 635, 289, 610, 674, 570, + 565, 702, 767, 702, 53, 104, 441, 809, 832, 833, + 832, 832, 515, 674, 767, 386, 611, 63, 272, 357, + 386, 603, 603, 973, 515, 566, 703, 703, 833, 365, + 165, 323, 165, 323, 148, 834, 834, 834, 569, 599, + 25, 117, 279, 918, 702, 36, 104, 180, 272, 425, + 767, 767, 703, 833, 365, 297 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab -enum { YYENOMEM = -2 }; - -#define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) +#define YYRECOVERING() (!!yyerrstatus) -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab -#define YYNOMEM goto yyexhaustedlab +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = YYTRANSLATE (yychar); \ + YYPOPSTACK (1); \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (&yylloc, yyscanner, YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) -#define YYRECOVERING() (!!yyerrstatus) +#define YYTERROR 1 +#define YYERRCODE 256 -#define YYBACKUP(Token, Value) \ - do \ - if (yychar == YYEMPTY) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - YYPOPSTACK (yylen); \ - yystate = *yyssp; \ - goto yybackup; \ - } \ - else \ - { \ - yyerror (&yylloc, yyscanner, YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ - while (0) - -/* Backward compatibility with an undocumented macro. - Use YYerror or YYUNDEF. */ -#define YYERRCODE YYUNDEF /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. If N is 0, then set CURRENT to the empty location which ends the previous symbol: RHS[0] (always defined). */ +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) #ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (N) \ - { \ - (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ - (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ - (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ - (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ - } \ - else \ - { \ - (Current).first_line = (Current).last_line = \ - YYRHSLOC (Rhs, 0).last_line; \ - (Current).first_column = (Current).last_column = \ - YYRHSLOC (Rhs, 0).last_column; \ - } \ - while (0) +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (YYID (N)) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (YYID (0)) +#endif + + +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef YY_LOCATION_PRINT +# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif #endif -#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) +#else +# define YYLEX yylex (&yylval, &yylloc, yyscanner) +#endif /* Enable debugging if requested. */ #if YYDEBUG @@ -404865,119 +409195,88 @@ enum { YYENOMEM = -2 }; # define YYFPRINTF fprintf # endif -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (0) - - -/* YYLOCATION_PRINT -- Print the location on the stream. - This macro was not mandated originally: define only if we know - we won't break user code: when these are the locations we know. */ - -# ifndef YYLOCATION_PRINT - -# if defined YY_LOCATION_PRINT - - /* Temporary convenience wrapper in case some people defined the - undocumented and private YY_LOCATION_PRINT macros. */ -# define YYLOCATION_PRINT(File, Loc) YY_LOCATION_PRINT(File, *(Loc)) - -# elif defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL - -/* Print *YYLOCP on YYO. Private, do not rely on its existence. */ - -YY_ATTRIBUTE_UNUSED -static int -yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp) -{ - int res = 0; - int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0; - if (0 <= yylocp->first_line) - { - res += YYFPRINTF (yyo, "%d", yylocp->first_line); - if (0 <= yylocp->first_column) - res += YYFPRINTF (yyo, ".%d", yylocp->first_column); - } - if (0 <= yylocp->last_line) - { - if (yylocp->first_line < yylocp->last_line) - { - res += YYFPRINTF (yyo, "-%d", yylocp->last_line); - if (0 <= end_col) - res += YYFPRINTF (yyo, ".%d", end_col); - } - else if (0 <= end_col && yylocp->first_column < end_col) - res += YYFPRINTF (yyo, "-%d", end_col); - } - return res; -} - -# define YYLOCATION_PRINT yy_location_print_ - - /* Temporary convenience wrapper in case some people defined the - undocumented and private YY_LOCATION_PRINT macros. */ -# define YY_LOCATION_PRINT(File, Loc) YYLOCATION_PRINT(File, &(Loc)) - -# else - -# define YYLOCATION_PRINT(File, Loc) ((void) 0) - /* Temporary convenience wrapper in case some people defined the - undocumented and private YY_LOCATION_PRINT macros. */ -# define YY_LOCATION_PRINT YYLOCATION_PRINT - -# endif -# endif /* !defined YYLOCATION_PRINT */ - - -# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ -do { \ - if (yydebug) \ - { \ - YYFPRINTF (stderr, "%s ", Title); \ - yy_symbol_print (stderr, \ - Kind, Value, Location, yyscanner); \ - YYFPRINTF (stderr, "\n"); \ - } \ -} while (0) - - -/*-----------------------------------. -| Print this symbol's value on YYO. | -`-----------------------------------*/ - +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value, Location, yyscanner); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, core_yyscan_t yyscanner) +#else static void -yy_symbol_value_print (FILE *yyo, - yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, core_yyscan_t yyscanner) +yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, yyscanner) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; + YYLTYPE const * const yylocationp; + core_yyscan_t yyscanner; +#endif { - FILE *yyoutput = yyo; - YY_USE (yyoutput); - YY_USE (yylocationp); - YY_USE (yyscanner); if (!yyvaluep) return; - YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN - YY_USE (yykind); - YY_IGNORE_MAYBE_UNINITIALIZED_END + YYUSE (yylocationp); + YYUSE (yyscanner); +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { + default: + break; + } } -/*---------------------------. -| Print this symbol on YYO. | -`---------------------------*/ +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, core_yyscan_t yyscanner) +#else static void -yy_symbol_print (FILE *yyo, - yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, core_yyscan_t yyscanner) +yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, yyscanner) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; + YYLTYPE const * const yylocationp; + core_yyscan_t yyscanner; +#endif { - YYFPRINTF (yyo, "%s %s (", - yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); - YYLOCATION_PRINT (yyo, yylocationp); - YYFPRINTF (yyo, ": "); - yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp, yyscanner); - YYFPRINTF (yyo, ")"); + YY_LOCATION_PRINT (yyoutput, *yylocationp); + YYFPRINTF (yyoutput, ": "); + yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, yyscanner); + YYFPRINTF (yyoutput, ")"); } /*------------------------------------------------------------------. @@ -404985,69 +409284,82 @@ yy_symbol_print (FILE *yyo, | TOP (included). | `------------------------------------------------------------------*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) +#else static void -yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) +yy_stack_print (bottom, top) + yytype_int16 *bottom; + yytype_int16 *top; +#endif { YYFPRINTF (stderr, "Stack now"); - for (; yybottom <= yytop; yybottom++) - { - int yybot = *yybottom; - YYFPRINTF (stderr, " %d", yybot); - } + for (; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); YYFPRINTF (stderr, "\n"); } -# define YY_STACK_PRINT(Bottom, Top) \ -do { \ - if (yydebug) \ - yy_stack_print ((Bottom), (Top)); \ -} while (0) +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) /*------------------------------------------------. | Report that the YYRULE is going to be reduced. | `------------------------------------------------*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) static void -yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, - int yyrule, core_yyscan_t yyscanner) +yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, core_yyscan_t yyscanner) +#else +static void +yy_reduce_print (yyvsp, yylsp, yyrule, yyscanner) + YYSTYPE *yyvsp; + YYLTYPE *yylsp; + int yyrule; + core_yyscan_t yyscanner; +#endif { - int yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; - YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", - yyrule - 1, yylno); + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { - YYFPRINTF (stderr, " $%d = ", yyi + 1); - yy_symbol_print (stderr, - YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), - &yyvsp[(yyi + 1) - (yynrhs)], - &(yylsp[(yyi + 1) - (yynrhs)]), yyscanner); - YYFPRINTF (stderr, "\n"); + fprintf (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)]) + , &(yylsp[(yyi + 1) - (yynrhs)]) , yyscanner); + fprintf (stderr, "\n"); } } -# define YY_REDUCE_PRINT(Rule) \ -do { \ - if (yydebug) \ - yy_reduce_print (yyssp, yyvsp, yylsp, Rule, yyscanner); \ -} while (0) +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, yylsp, Rule, yyscanner); \ +} while (YYID (0)) /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ -# define YYDPRINTF(Args) ((void) 0) -# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) # define YY_STACK_PRINT(Bottom, Top) # define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ /* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH +#ifndef YYINITDEPTH # define YYINITDEPTH 200 #endif @@ -405062,30 +409374,270 @@ int yydebug; # define YYMAXDEPTH 10000 #endif + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen (const char *yystr) +#else +static YYSIZE_T +yystrlen (yystr) + const char *yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char * +yystpcpy (char *yydest, const char *yysrc) +#else +static char * +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +#endif +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into YYRESULT an error message about the unexpected token + YYCHAR while in state YYSTATE. Return the number of bytes copied, + including the terminating null byte. If YYRESULT is null, do not + copy anything; just return the number of bytes that would be + copied. As a special case, return 0 if an ordinary "syntax error" + message will do. Return YYSIZE_MAXIMUM if overflow occurs during + size calculation. */ +static YYSIZE_T +yysyntax_error (char *yyresult, int yystate, int yychar) +{ + int yyn = yypact[yystate]; + if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) + return 0; + else + { + int yytype = YYTRANSLATE (yychar); + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + int yysize_overflow = 0; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + int yyx; + +# if 0 + /* This is so xgettext sees the translatable formats that are + constructed on the fly. */ + YY_("syntax error, unexpected %s"); + YY_("syntax error, unexpected %s, expecting %s"); + YY_("syntax error, unexpected %s, expecting %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); +# endif + char *yyfmt; + char const *yyf; + static char const yyunexpected[] = "syntax error, unexpected %s"; + static char const yyexpecting[] = ", expecting %s"; + static char const yyor[] = " or %s"; + char yyformat[sizeof yyunexpected + + sizeof yyexpecting - 1 + + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) + * (sizeof yyor - 1))]; + char const *yyprefix = yyexpecting; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 1; + + yyarg[0] = yytname[yytype]; + yyfmt = yystpcpy (yyformat, yyunexpected); + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + yyformat[sizeof yyunexpected - 1] = '\0'; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr (0, yytname[yyx]); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + yyfmt = yystpcpy (yyfmt, yyprefix); + yyprefix = yyor; + } + yyf = YY_(yyformat); + yysize1 = yysize + yystrlen (yyf); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + if (yysize_overflow) + return YYSIZE_MAXIMUM; + if (yyresult) + { + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + char *yyp = yyresult; + int yyi = 0; + while ((*yyp = *yyf) != '\0') + { + if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyf += 2; + } + else + { + yyp++; + yyf++; + } + } + } + return yysize; + } +} +#endif /* YYERROR_VERBOSE */ + /*-----------------------------------------------. | Release the memory associated to this symbol. | `-----------------------------------------------*/ +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, core_yyscan_t yyscanner) +#else static void -yydestruct (const char *yymsg, - yysymbol_kind_t yykind, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, core_yyscan_t yyscanner) +yydestruct (yymsg, yytype, yyvaluep, yylocationp, yyscanner) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; + YYLTYPE *yylocationp; + core_yyscan_t yyscanner; +#endif { - YY_USE (yyvaluep); - YY_USE (yylocationp); - YY_USE (yyscanner); + YYUSE (yyvaluep); + YYUSE (yylocationp); + YYUSE (yyscanner); + if (!yymsg) yymsg = "Deleting"; - YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { - YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN - YY_USE (yykind); - YY_IGNORE_MAYBE_UNINITIALIZED_END + default: + break; + } } + + +/* Prevent warnings from -Wmissing-prototypes. */ + +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (core_yyscan_t yyscanner); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ @@ -405096,217 +409648,221 @@ yydestruct (const char *yymsg, | yyparse. | `----------*/ +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void *YYPARSE_PARAM) +#else +int +yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) int yyparse (core_yyscan_t yyscanner) +#else +int +yyparse (yyscanner) + core_yyscan_t yyscanner; +#endif +#endif { -/* Lookahead token kind. */ + /* The look-ahead symbol. */ int yychar; +/* The semantic value of the look-ahead symbol. */ +YYSTYPE yylval; -/* The semantic value of the lookahead symbol. */ -/* Default value used for initialization, for pacifying older GCCs - or non-GCC compilers. */ -YY_INITIAL_VALUE (static YYSTYPE yyval_default;) -YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); - -/* Location data for the lookahead symbol. */ -static YYLTYPE yyloc_default -# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL - = { 1, 1, 1, 1 } -# endif -; -YYLTYPE yylloc = yyloc_default; - - /* Number of syntax errors so far. */ - int yynerrs = 0; (void)yynerrs; +/* Number of syntax errors so far. */ +int yynerrs; +/* Location data for the look-ahead symbol. */ +YYLTYPE yylloc; - yy_state_fast_t yystate = 0; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus = 0; - - /* Refer to the stacks through separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* Their size. */ - YYPTRDIFF_T yystacksize = YYINITDEPTH; - - /* The state stack: array, bottom, top. */ - yy_state_t yyssa[YYINITDEPTH]; - yy_state_t *yyss = yyssa; - yy_state_t *yyssp = yyss; + int yystate; + int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Look-ahead token as an internal (translated) token number. */ + int yytoken = 0; +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss = yyssa; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + YYSTYPE *yyvsp; + + /* The location stack. */ + YYLTYPE yylsa[YYINITDEPTH]; + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + /* The locations where the error started and ended. */ + YYLTYPE yyerror_range[2]; - /* The semantic value stack: array, bottom, top. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs = yyvsa; - YYSTYPE *yyvsp = yyvs; +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) - /* The location stack: array, bottom, top. */ - YYLTYPE yylsa[YYINITDEPTH]; - YYLTYPE *yyls = yylsa; - YYLTYPE *yylsp = yyls; + YYSIZE_T yystacksize = YYINITDEPTH; - int yyn; - /* The return value of yyparse. */ - int yyresult; - /* Lookahead symbol kind. */ - yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; YYLTYPE yyloc; - /* The locations where the error started and ended. */ - YYLTYPE yyerror_range[3]; - - - -#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) - /* The number of symbols on the RHS of the reduced rule. Keep to zero when no symbol should be popped. */ int yylen = 0; YYDPRINTF ((stderr, "Starting parse\n")); - yychar = YYEMPTY; /* Cause a token to be read. */ + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; (void)yynerrs; + yychar = YYEMPTY; /* Cause a token to be read. */ - yylsp[0] = yylloc; - goto yysetstate; + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + yyssp = yyss; + yyvsp = yyvs; + yylsp = yyls; +#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL + /* Initialize the default location before parsing starts. */ + yylloc.first_line = yylloc.last_line = 1; + yylloc.first_column = yylloc.last_column = 0; +#endif + + goto yysetstate; /*------------------------------------------------------------. -| yynewstate -- push a new state, which is found in yystate. | +| yynewstate -- Push a new state, which is found in yystate. | `------------------------------------------------------------*/ -yynewstate: + yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks. */ yyssp++; - -/*--------------------------------------------------------------------. -| yysetstate -- set current state (the top of the stack) to yystate. | -`--------------------------------------------------------------------*/ -yysetstate: - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); - YY_ASSERT (0 <= yystate && yystate < YYNSTATES); - YY_IGNORE_USELESS_CAST_BEGIN - *yyssp = YY_CAST (yy_state_t, yystate); - YY_IGNORE_USELESS_CAST_END - YY_STACK_PRINT (yyss, yyssp); + yysetstate: + *yyssp = yystate; if (yyss + yystacksize - 1 <= yyssp) -#if !defined yyoverflow && !defined YYSTACK_RELOCATE - YYNOMEM; -#else { /* Get the current used size of the three stacks, in elements. */ - YYPTRDIFF_T yysize = yyssp - yyss + 1; + YYSIZE_T yysize = yyssp - yyss + 1; -# if defined yyoverflow +#ifdef yyoverflow { - /* Give user a chance to reallocate the stack. Use copies of - these so that the &'s don't force the real ones into - memory. */ - yy_state_t *yyss1 = yyss; - YYSTYPE *yyvs1 = yyvs; - YYLTYPE *yyls1 = yyls; - - /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. This used to be a - conditional around just the two extra args, but that might - be undefined if yyoverflow is a macro. */ - yyoverflow (YY_("memory exhausted"), - &yyss1, yysize * YYSIZEOF (*yyssp), - &yyvs1, yysize * YYSIZEOF (*yyvsp), - &yyls1, yysize * YYSIZEOF (*yylsp), - &yystacksize); - yyss = yyss1; - yyvs = yyvs1; - yyls = yyls1; + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + YYLTYPE *yyls1 = yyls; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yyls1, yysize * sizeof (*yylsp), + &yystacksize); + yyls = yyls1; + yyss = yyss1; + yyvs = yyvs1; } -# else /* defined YYSTACK_RELOCATE */ +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) - YYNOMEM; + goto yyexhaustedlab; yystacksize *= 2; if (YYMAXDEPTH < yystacksize) - yystacksize = YYMAXDEPTH; + yystacksize = YYMAXDEPTH; { - yy_state_t *yyss1 = yyss; - union yyalloc *yyptr = - YY_CAST (union yyalloc *, - YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); - if (! yyptr) - YYNOMEM; - YYSTACK_RELOCATE (yyss_alloc, yyss); - YYSTACK_RELOCATE (yyvs_alloc, yyvs); - YYSTACK_RELOCATE (yyls_alloc, yyls); + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + YYSTACK_RELOCATE (yyls); # undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE (yyss1); + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); } # endif +#endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; yylsp = yyls + yysize - 1; - YY_IGNORE_USELESS_CAST_BEGIN - YYDPRINTF ((stderr, "Stack size increased to %ld\n", - YY_CAST (long, yystacksize))); - YY_IGNORE_USELESS_CAST_END + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); if (yyss + yystacksize - 1 <= yyssp) - YYABORT; + YYABORT; } -#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ - - if (yystate == YYFINAL) - YYACCEPT; + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); goto yybackup; - /*-----------. | yybackup. | `-----------*/ yybackup: + /* Do appropriate processing given the current state. Read a - lookahead token if we need one and don't already have one. */ + look-ahead token if we need one and don't already have one. */ - /* First try to decide what to do without reference to lookahead token. */ + /* First try to decide what to do without reference to look-ahead token. */ yyn = yypact[yystate]; - if (yypact_value_is_default (yyn)) + if (yyn == YYPACT_NINF) goto yydefault; - /* Not known => get a lookahead token if don't already have one. */ + /* Not known => get a look-ahead token if don't already have one. */ - /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ + /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ if (yychar == YYEMPTY) { - YYDPRINTF ((stderr, "Reading a token\n")); - yychar = yylex (&yylval, &yylloc, yyscanner); + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; } if (yychar <= YYEOF) { - yychar = YYEOF; - yytoken = YYSYMBOL_YYEOF; + yychar = yytoken = YYEOF; YYDPRINTF ((stderr, "Now at end of input.\n")); } - else if (yychar == YYerror) - { - /* The scanner already issued an error message, process directly - to error recovery. But do not keep the error token as - lookahead, it is too special and may lead us to an endless - loop in error recovery. */ - yychar = YYUNDEF; - yytoken = YYSYMBOL_YYerror; - yyerror_range[1] = yylloc; - goto yyerrlab1; - } else { yytoken = YYTRANSLATE (yychar); @@ -405321,27 +409877,30 @@ YYLTYPE yylloc = yyloc_default; yyn = yytable[yyn]; if (yyn <= 0) { - if (yytable_value_is_error (yyn)) - goto yyerrlab; + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; yyn = -yyn; goto yyreduce; } + if (yyn == YYFINAL) + YYACCEPT; + /* Count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus) yyerrstatus--; - /* Shift the lookahead token. */ + /* Shift the look-ahead token. */ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + yystate = yyn; - YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN *++yyvsp = yylval; - YY_IGNORE_MAYBE_UNINITIALIZED_END *++yylsp = yylloc; - - /* Discard the shifted token. */ - yychar = YYEMPTY; goto yynewstate; @@ -405356,14 +409915,14 @@ YYLTYPE yylloc = yyloc_default; /*-----------------------------. -| yyreduce -- do a reduction. | +| yyreduce -- Do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; /* If YYLEN is nonzero, implement the default value of the action: - '$$ = $1'. + `$$ = $1'. Otherwise, the following line sets YYVAL to garbage. This behavior is undocumented and Bison @@ -405372,2347 +409931,2101 @@ YYLTYPE yylloc = yyloc_default; GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; - /* Default location. */ + /* Default location. */ YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); - yyerror_range[1] = yyloc; YY_REDUCE_PRINT (yyn); switch (yyn) { - case 2: /* stmtblock: stmtmulti */ + case 2: #line 501 "third_party/libpg_query/grammar/grammar.y" - { - pg_yyget_extra(yyscanner)->parsetree = (yyvsp[0].list); - } -#line 18871 "third_party/libpg_query/grammar/grammar_out.cpp" + { + pg_yyget_extra(yyscanner)->parsetree = (yyvsp[(1) - (1)].list); + ;} break; - case 3: /* stmtmulti: stmtmulti ';' stmt */ + case 3: #line 517 "third_party/libpg_query/grammar/grammar.y" - { - if ((yyvsp[-2].list) != NIL) + { + if ((yyvsp[(1) - (3)].list) != NIL) { /* update length of previous stmt */ - updateRawStmtEnd(llast_node(PGRawStmt, (yyvsp[-2].list)), (yylsp[-1])); + updateRawStmtEnd(llast_node(PGRawStmt, (yyvsp[(1) - (3)].list)), (yylsp[(2) - (3)])); } - if ((yyvsp[0].node) != NULL) - (yyval.list) = lappend((yyvsp[-2].list), makeRawStmt((yyvsp[0].node), (yylsp[-1]) + 1)); + if ((yyvsp[(3) - (3)].node) != NULL) + (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeRawStmt((yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]) + 1)); else - (yyval.list) = (yyvsp[-2].list); - } -#line 18887 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.list) = (yyvsp[(1) - (3)].list); + ;} break; - case 4: /* stmtmulti: stmt */ + case 4: #line 529 "third_party/libpg_query/grammar/grammar.y" - { - if ((yyvsp[0].node) != NULL) - (yyval.list) = list_make1(makeRawStmt((yyvsp[0].node), 0)); + { + if ((yyvsp[(1) - (1)].node) != NULL) + (yyval.list) = list_make1(makeRawStmt((yyvsp[(1) - (1)].node), 0)); else (yyval.list) = NIL; - } -#line 18898 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 45: /* stmt: %empty */ + case 45: #line 578 "third_party/libpg_query/grammar/grammar.y" - { (yyval.node) = NULL; } -#line 18904 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 46: /* AlterTableStmt: ALTER TABLE relation_expr alter_table_cmds */ + case 46: #line 10 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableStmt *n = makeNode(PGAlterTableStmt); - n->relation = (yyvsp[-1].range); - n->cmds = (yyvsp[0].list); + n->relation = (yyvsp[(3) - (4)].range); + n->cmds = (yyvsp[(4) - (4)].list); n->relkind = PG_OBJECT_TABLE; n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 18917 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 47: /* AlterTableStmt: ALTER TABLE IF_P EXISTS relation_expr alter_table_cmds */ + case 47: #line 19 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableStmt *n = makeNode(PGAlterTableStmt); - n->relation = (yyvsp[-1].range); - n->cmds = (yyvsp[0].list); + n->relation = (yyvsp[(5) - (6)].range); + n->cmds = (yyvsp[(6) - (6)].list); n->relkind = PG_OBJECT_TABLE; n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 18930 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 48: /* AlterTableStmt: ALTER INDEX qualified_name alter_table_cmds */ + case 48: #line 28 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableStmt *n = makeNode(PGAlterTableStmt); - n->relation = (yyvsp[-1].range); - n->cmds = (yyvsp[0].list); + n->relation = (yyvsp[(3) - (4)].range); + n->cmds = (yyvsp[(4) - (4)].list); n->relkind = PG_OBJECT_INDEX; n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 18943 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 49: /* AlterTableStmt: ALTER INDEX IF_P EXISTS qualified_name alter_table_cmds */ + case 49: #line 37 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableStmt *n = makeNode(PGAlterTableStmt); - n->relation = (yyvsp[-1].range); - n->cmds = (yyvsp[0].list); + n->relation = (yyvsp[(5) - (6)].range); + n->cmds = (yyvsp[(6) - (6)].list); n->relkind = PG_OBJECT_INDEX; n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 18956 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 50: /* AlterTableStmt: ALTER SEQUENCE qualified_name alter_table_cmds */ + case 50: #line 46 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableStmt *n = makeNode(PGAlterTableStmt); - n->relation = (yyvsp[-1].range); - n->cmds = (yyvsp[0].list); + n->relation = (yyvsp[(3) - (4)].range); + n->cmds = (yyvsp[(4) - (4)].list); n->relkind = PG_OBJECT_SEQUENCE; n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 18969 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 51: /* AlterTableStmt: ALTER SEQUENCE IF_P EXISTS qualified_name alter_table_cmds */ + case 51: #line 55 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableStmt *n = makeNode(PGAlterTableStmt); - n->relation = (yyvsp[-1].range); - n->cmds = (yyvsp[0].list); + n->relation = (yyvsp[(5) - (6)].range); + n->cmds = (yyvsp[(6) - (6)].list); n->relkind = PG_OBJECT_SEQUENCE; n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 18982 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 52: /* AlterTableStmt: ALTER VIEW qualified_name alter_table_cmds */ + case 52: #line 64 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableStmt *n = makeNode(PGAlterTableStmt); - n->relation = (yyvsp[-1].range); - n->cmds = (yyvsp[0].list); + n->relation = (yyvsp[(3) - (4)].range); + n->cmds = (yyvsp[(4) - (4)].list); n->relkind = PG_OBJECT_VIEW; n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 18995 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 53: /* AlterTableStmt: ALTER VIEW IF_P EXISTS qualified_name alter_table_cmds */ + case 53: #line 73 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableStmt *n = makeNode(PGAlterTableStmt); - n->relation = (yyvsp[-1].range); - n->cmds = (yyvsp[0].list); + n->relation = (yyvsp[(5) - (6)].range); + n->cmds = (yyvsp[(6) - (6)].list); n->relkind = PG_OBJECT_VIEW; n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19008 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 54: /* alter_identity_column_option_list: alter_identity_column_option */ + case 54: #line 86 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.list) = list_make1((yyvsp[0].defelt)); } -#line 19014 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; - case 55: /* alter_identity_column_option_list: alter_identity_column_option_list alter_identity_column_option */ + case 55: #line 88 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].defelt)); } -#line 19020 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} break; - case 56: /* alter_column_default: SET DEFAULT a_expr */ + case 56: #line 93 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.node) = (yyvsp[0].node); } -#line 19026 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(3) - (3)].node); ;} break; - case 57: /* alter_column_default: DROP DEFAULT */ + case 57: #line 94 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.node) = NULL; } -#line 19032 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 58: /* alter_identity_column_option: RESTART */ + case 58: #line 100 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = makeDefElem("restart", NULL, (yylsp[0])); - } -#line 19040 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("restart", NULL, (yylsp[(1) - (1)])); + ;} break; - case 59: /* alter_identity_column_option: RESTART opt_with NumericOnly */ + case 59: #line 104 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[0].value), (yylsp[-2])); - } -#line 19048 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)])); + ;} break; - case 60: /* alter_identity_column_option: SET SeqOptElem */ + case 60: #line 108 "third_party/libpg_query/grammar/statements/alter_table.y" - { - if (strcmp((yyvsp[0].defelt)->defname, "as") == 0 || - strcmp((yyvsp[0].defelt)->defname, "restart") == 0 || - strcmp((yyvsp[0].defelt)->defname, "owned_by") == 0) + { + if (strcmp((yyvsp[(2) - (2)].defelt)->defname, "as") == 0 || + strcmp((yyvsp[(2) - (2)].defelt)->defname, "restart") == 0 || + strcmp((yyvsp[(2) - (2)].defelt)->defname, "owned_by") == 0) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), - errmsg("sequence option \"%s\" not supported here", (yyvsp[0].defelt)->defname), - parser_errposition((yylsp[0])))); - (yyval.defelt) = (yyvsp[0].defelt); - } -#line 19063 "third_party/libpg_query/grammar/grammar_out.cpp" + errmsg("sequence option \"%s\" not supported here", (yyvsp[(2) - (2)].defelt)->defname), + parser_errposition((yylsp[(2) - (2)])))); + (yyval.defelt) = (yyvsp[(2) - (2)].defelt); + ;} break; - case 61: /* alter_identity_column_option: SET GENERATED generated_when */ + case 61: #line 119 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = makeDefElem("generated", (PGNode *) makeInteger((yyvsp[0].ival)), (yylsp[-2])); - } -#line 19071 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("generated", (PGNode *) makeInteger((yyvsp[(3) - (3)].ival)), (yylsp[(1) - (3)])); + ;} break; - case 62: /* alter_generic_option_list: alter_generic_option_elem */ + case 62: #line 127 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.list) = list_make1((yyvsp[0].defelt)); - } -#line 19079 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); + ;} break; - case 63: /* alter_generic_option_list: alter_generic_option_list ',' alter_generic_option_elem */ + case 63: #line 131 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt)); - } -#line 19087 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); + ;} break; - case 64: /* alter_table_cmd: ADD_P columnDef */ + case 64: #line 140 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_AddColumn; - n->def = (yyvsp[0].node); + n->def = (yyvsp[(2) - (2)].node); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19099 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 65: /* alter_table_cmd: ADD_P IF_P NOT EXISTS columnDef */ + case 65: #line 149 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_AddColumn; - n->def = (yyvsp[0].node); + n->def = (yyvsp[(5) - (5)].node); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19111 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 66: /* alter_table_cmd: ADD_P COLUMN columnDef */ + case 66: #line 158 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_AddColumn; - n->def = (yyvsp[0].node); + n->def = (yyvsp[(3) - (3)].node); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19123 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 67: /* alter_table_cmd: ADD_P COLUMN IF_P NOT EXISTS columnDef */ + case 67: #line 167 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_AddColumn; - n->def = (yyvsp[0].node); + n->def = (yyvsp[(6) - (6)].node); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19135 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 68: /* alter_table_cmd: ALTER opt_column ColId alter_column_default */ + case 68: #line 176 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_ColumnDefault; - n->name = (yyvsp[-1].str); - n->def = (yyvsp[0].node); + n->name = (yyvsp[(3) - (4)].str); + n->def = (yyvsp[(4) - (4)].node); (yyval.node) = (PGNode *)n; - } -#line 19147 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 69: /* alter_table_cmd: ALTER opt_column ColId DROP NOT NULL_P */ + case 69: #line 185 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_DropNotNull; - n->name = (yyvsp[-3].str); + n->name = (yyvsp[(3) - (6)].str); (yyval.node) = (PGNode *)n; - } -#line 19158 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 70: /* alter_table_cmd: ALTER opt_column ColId SET NOT NULL_P */ + case 70: #line 193 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_SetNotNull; - n->name = (yyvsp[-3].str); + n->name = (yyvsp[(3) - (6)].str); (yyval.node) = (PGNode *)n; - } -#line 19169 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 71: /* alter_table_cmd: ALTER opt_column ColId SET STATISTICS SignedIconst */ + case 71: #line 201 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_SetStatistics; - n->name = (yyvsp[-3].str); - n->def = (PGNode *) makeInteger((yyvsp[0].ival)); + n->name = (yyvsp[(3) - (6)].str); + n->def = (PGNode *) makeInteger((yyvsp[(6) - (6)].ival)); (yyval.node) = (PGNode *)n; - } -#line 19181 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 72: /* alter_table_cmd: ALTER opt_column ColId SET reloptions */ + case 72: #line 210 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_SetOptions; - n->name = (yyvsp[-2].str); - n->def = (PGNode *) (yyvsp[0].list); + n->name = (yyvsp[(3) - (5)].str); + n->def = (PGNode *) (yyvsp[(5) - (5)].list); (yyval.node) = (PGNode *)n; - } -#line 19193 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 73: /* alter_table_cmd: ALTER opt_column ColId RESET reloptions */ + case 73: #line 219 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_ResetOptions; - n->name = (yyvsp[-2].str); - n->def = (PGNode *) (yyvsp[0].list); + n->name = (yyvsp[(3) - (5)].str); + n->def = (PGNode *) (yyvsp[(5) - (5)].list); (yyval.node) = (PGNode *)n; - } -#line 19205 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 74: /* alter_table_cmd: ALTER opt_column ColId SET STORAGE ColId */ + case 74: #line 228 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_SetStorage; - n->name = (yyvsp[-3].str); - n->def = (PGNode *) makeString((yyvsp[0].str)); + n->name = (yyvsp[(3) - (6)].str); + n->def = (PGNode *) makeString((yyvsp[(6) - (6)].str)); (yyval.node) = (PGNode *)n; - } -#line 19217 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 75: /* alter_table_cmd: ALTER opt_column ColId ADD_P GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList */ + case 75: #line 237 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); PGConstraint *c = makeNode(PGConstraint); c->contype = PG_CONSTR_IDENTITY; - c->generated_when = (yyvsp[-3].ival); - c->options = (yyvsp[0].list); - c->location = (yylsp[-4]); + c->generated_when = (yyvsp[(6) - (9)].ival); + c->options = (yyvsp[(9) - (9)].list); + c->location = (yylsp[(5) - (9)]); n->subtype = PG_AT_AddIdentity; - n->name = (yyvsp[-6].str); + n->name = (yyvsp[(3) - (9)].str); n->def = (PGNode *) c; (yyval.node) = (PGNode *)n; - } -#line 19237 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 76: /* alter_table_cmd: ALTER opt_column ColId alter_identity_column_option_list */ + case 76: #line 254 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_SetIdentity; - n->name = (yyvsp[-1].str); - n->def = (PGNode *) (yyvsp[0].list); + n->name = (yyvsp[(3) - (4)].str); + n->def = (PGNode *) (yyvsp[(4) - (4)].list); (yyval.node) = (PGNode *)n; - } -#line 19249 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 77: /* alter_table_cmd: ALTER opt_column ColId DROP IDENTITY_P */ + case 77: #line 263 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = AT_DropIdentity; - n->name = (yyvsp[-2].str); + n->name = (yyvsp[(3) - (5)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19261 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 78: /* alter_table_cmd: ALTER opt_column ColId DROP IDENTITY_P IF_P EXISTS */ + case 78: #line 272 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = AT_DropIdentity; - n->name = (yyvsp[-4].str); + n->name = (yyvsp[(3) - (7)].str); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19273 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 79: /* alter_table_cmd: DROP opt_column IF_P EXISTS ColId opt_drop_behavior */ + case 79: #line 281 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_DropColumn; - n->name = (yyvsp[-1].str); - n->behavior = (yyvsp[0].dbehavior); + n->name = (yyvsp[(5) - (6)].str); + n->behavior = (yyvsp[(6) - (6)].dbehavior); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19286 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 80: /* alter_table_cmd: DROP opt_column ColId opt_drop_behavior */ + case 80: #line 291 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_DropColumn; - n->name = (yyvsp[-1].str); - n->behavior = (yyvsp[0].dbehavior); + n->name = (yyvsp[(3) - (4)].str); + n->behavior = (yyvsp[(4) - (4)].dbehavior); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19299 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 81: /* alter_table_cmd: ALTER opt_column ColId opt_set_data TYPE_P Typename opt_collate_clause alter_using */ + case 81: #line 304 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); PGColumnDef *def = makeNode(PGColumnDef); n->subtype = PG_AT_AlterColumnType; - n->name = (yyvsp[-5].str); + n->name = (yyvsp[(3) - (8)].str); n->def = (PGNode *) def; /* We only use these fields of the PGColumnDef node */ - def->typeName = (yyvsp[-2].typnam); - def->collClause = (PGCollateClause *) (yyvsp[-1].node); - def->raw_default = (yyvsp[0].node); - def->location = (yylsp[-5]); + def->typeName = (yyvsp[(6) - (8)].typnam); + def->collClause = (PGCollateClause *) (yyvsp[(7) - (8)].node); + def->raw_default = (yyvsp[(8) - (8)].node); + def->location = (yylsp[(3) - (8)]); (yyval.node) = (PGNode *)n; - } -#line 19317 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 82: /* alter_table_cmd: ALTER opt_column ColId alter_generic_options */ + case 82: #line 319 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_AlterColumnGenericOptions; - n->name = (yyvsp[-1].str); - n->def = (PGNode *) (yyvsp[0].list); + n->name = (yyvsp[(3) - (4)].str); + n->def = (PGNode *) (yyvsp[(4) - (4)].list); (yyval.node) = (PGNode *)n; - } -#line 19329 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 83: /* alter_table_cmd: ADD_P TableConstraint */ + case 83: #line 328 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_AddConstraint; - n->def = (yyvsp[0].node); + n->def = (yyvsp[(2) - (2)].node); (yyval.node) = (PGNode *)n; - } -#line 19340 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 84: /* alter_table_cmd: ALTER CONSTRAINT name ConstraintAttributeSpec */ + case 84: #line 336 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); PGConstraint *c = makeNode(PGConstraint); n->subtype = PG_AT_AlterConstraint; n->def = (PGNode *) c; c->contype = PG_CONSTR_FOREIGN; /* others not supported, yet */ - c->conname = (yyvsp[-1].str); - processCASbits((yyvsp[0].ival), (yylsp[0]), "ALTER CONSTRAINT statement", + c->conname = (yyvsp[(3) - (4)].str); + processCASbits((yyvsp[(4) - (4)].ival), (yylsp[(4) - (4)]), "ALTER CONSTRAINT statement", &c->deferrable, &c->initdeferred, NULL, NULL, yyscanner); (yyval.node) = (PGNode *)n; - } -#line 19358 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 85: /* alter_table_cmd: VALIDATE CONSTRAINT name */ + case 85: #line 351 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_ValidateConstraint; - n->name = (yyvsp[0].str); + n->name = (yyvsp[(3) - (3)].str); (yyval.node) = (PGNode *)n; - } -#line 19369 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 86: /* alter_table_cmd: DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior */ + case 86: #line 359 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_DropConstraint; - n->name = (yyvsp[-1].str); - n->behavior = (yyvsp[0].dbehavior); + n->name = (yyvsp[(5) - (6)].str); + n->behavior = (yyvsp[(6) - (6)].dbehavior); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19382 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 87: /* alter_table_cmd: DROP CONSTRAINT name opt_drop_behavior */ + case 87: #line 369 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_DropConstraint; - n->name = (yyvsp[-1].str); - n->behavior = (yyvsp[0].dbehavior); + n->name = (yyvsp[(3) - (4)].str); + n->behavior = (yyvsp[(4) - (4)].dbehavior); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19395 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 88: /* alter_table_cmd: SET LOGGED */ + case 88: #line 379 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_SetLogged; (yyval.node) = (PGNode *)n; - } -#line 19405 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 89: /* alter_table_cmd: SET UNLOGGED */ + case 89: #line 386 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_SetUnLogged; (yyval.node) = (PGNode *)n; - } -#line 19415 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 90: /* alter_table_cmd: SET reloptions */ + case 90: #line 393 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_SetRelOptions; - n->def = (PGNode *)(yyvsp[0].list); + n->def = (PGNode *)(yyvsp[(2) - (2)].list); (yyval.node) = (PGNode *)n; - } -#line 19426 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 91: /* alter_table_cmd: RESET reloptions */ + case 91: #line 401 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_ResetRelOptions; - n->def = (PGNode *)(yyvsp[0].list); + n->def = (PGNode *)(yyvsp[(2) - (2)].list); (yyval.node) = (PGNode *)n; - } -#line 19437 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 92: /* alter_table_cmd: alter_generic_options */ + case 92: #line 408 "third_party/libpg_query/grammar/statements/alter_table.y" - { + { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_GenericOptions; - n->def = (PGNode *)(yyvsp[0].list); + n->def = (PGNode *)(yyvsp[(1) - (1)].list); (yyval.node) = (PGNode *) n; - } -#line 19448 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 93: /* alter_using: USING a_expr */ + case 93: #line 418 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.node) = (yyvsp[0].node); } -#line 19454 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 94: /* alter_using: %empty */ + case 94: #line 419 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.node) = NULL; } -#line 19460 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 95: /* alter_generic_option_elem: generic_option_elem */ + case 95: #line 425 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = (yyvsp[0].defelt); - } -#line 19468 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = (yyvsp[(1) - (1)].defelt); + ;} break; - case 96: /* alter_generic_option_elem: SET generic_option_elem */ + case 96: #line 429 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = (yyvsp[0].defelt); + { + (yyval.defelt) = (yyvsp[(2) - (2)].defelt); (yyval.defelt)->defaction = PG_DEFELEM_SET; - } -#line 19477 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 97: /* alter_generic_option_elem: ADD_P generic_option_elem */ + case 97: #line 434 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = (yyvsp[0].defelt); + { + (yyval.defelt) = (yyvsp[(2) - (2)].defelt); (yyval.defelt)->defaction = PG_DEFELEM_ADD; - } -#line 19486 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 98: /* alter_generic_option_elem: DROP generic_option_name */ + case 98: #line 439 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = makeDefElemExtended(NULL, (yyvsp[0].str), NULL, DEFELEM_DROP, (yylsp[0])); - } -#line 19494 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElemExtended(NULL, (yyvsp[(2) - (2)].str), NULL, DEFELEM_DROP, (yylsp[(2) - (2)])); + ;} break; - case 99: /* alter_table_cmds: alter_table_cmd */ + case 99: #line 446 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 19500 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 100: /* alter_table_cmds: alter_table_cmds ',' alter_table_cmd */ + case 100: #line 447 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 19506 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 101: /* alter_generic_options: OPTIONS '(' alter_generic_option_list ')' */ + case 101: #line 452 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 19512 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 102: /* opt_set_data: SET DATA_P */ + case 102: #line 456 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.ival) = 1; } -#line 19518 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 1; ;} break; - case 103: /* opt_set_data: SET */ + case 103: #line 457 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.ival) = 0; } -#line 19524 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 104: /* opt_set_data: %empty */ + case 104: #line 458 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.ival) = 0; } -#line 19530 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 105: /* DeallocateStmt: DEALLOCATE name */ + case 105: #line 8 "third_party/libpg_query/grammar/statements/deallocate.y" - { + { PGDeallocateStmt *n = makeNode(PGDeallocateStmt); - n->name = (yyvsp[0].str); + n->name = (yyvsp[(2) - (2)].str); (yyval.node) = (PGNode *) n; - } -#line 19540 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 106: /* DeallocateStmt: DEALLOCATE PREPARE name */ + case 106: #line 14 "third_party/libpg_query/grammar/statements/deallocate.y" - { + { PGDeallocateStmt *n = makeNode(PGDeallocateStmt); - n->name = (yyvsp[0].str); + n->name = (yyvsp[(3) - (3)].str); (yyval.node) = (PGNode *) n; - } -#line 19550 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 107: /* DeallocateStmt: DEALLOCATE ALL */ + case 107: #line 20 "third_party/libpg_query/grammar/statements/deallocate.y" - { + { PGDeallocateStmt *n = makeNode(PGDeallocateStmt); n->name = NULL; (yyval.node) = (PGNode *) n; - } -#line 19560 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 108: /* DeallocateStmt: DEALLOCATE PREPARE ALL */ + case 108: #line 26 "third_party/libpg_query/grammar/statements/deallocate.y" - { + { PGDeallocateStmt *n = makeNode(PGDeallocateStmt); n->name = NULL; (yyval.node) = (PGNode *) n; - } -#line 19570 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 109: /* qualified_name: ColIdOrString */ + case 109: #line 10 "third_party/libpg_query/grammar/statements/common.y" - { - (yyval.range) = makeRangeVar(NULL, (yyvsp[0].str), (yylsp[0])); - } -#line 19578 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.range) = makeRangeVar(NULL, (yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 110: /* qualified_name: ColId indirection */ + case 110: #line 14 "third_party/libpg_query/grammar/statements/common.y" - { - check_qualified_name((yyvsp[0].list), yyscanner); - (yyval.range) = makeRangeVar(NULL, NULL, (yylsp[-1])); - switch (list_length((yyvsp[0].list))) + { + check_qualified_name((yyvsp[(2) - (2)].list), yyscanner); + (yyval.range) = makeRangeVar(NULL, NULL, (yylsp[(1) - (2)])); + switch (list_length((yyvsp[(2) - (2)].list))) { case 1: (yyval.range)->catalogname = NULL; - (yyval.range)->schemaname = (yyvsp[-1].str); - (yyval.range)->relname = strVal(linitial((yyvsp[0].list))); + (yyval.range)->schemaname = (yyvsp[(1) - (2)].str); + (yyval.range)->relname = strVal(linitial((yyvsp[(2) - (2)].list))); break; case 2: - (yyval.range)->catalogname = (yyvsp[-1].str); - (yyval.range)->schemaname = strVal(linitial((yyvsp[0].list))); - (yyval.range)->relname = strVal(lsecond((yyvsp[0].list))); + (yyval.range)->catalogname = (yyvsp[(1) - (2)].str); + (yyval.range)->schemaname = strVal(linitial((yyvsp[(2) - (2)].list))); + (yyval.range)->relname = strVal(lsecond((yyvsp[(2) - (2)].list))); break; case 3: default: ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("improper qualified name (too many dotted names): %s", - NameListToString(lcons(makeString((yyvsp[-1].str)), (yyvsp[0].list)))), - parser_errposition((yylsp[-1])))); + NameListToString(lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)))), + parser_errposition((yylsp[(1) - (2)])))); break; } - } -#line 19608 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 111: /* ColId: IDENT */ + case 111: #line 44 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19614 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 112: /* ColId: unreserved_keyword */ + case 112: #line 45 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 19620 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 113: /* ColId: col_name_keyword */ + case 113: #line 46 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 19626 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 114: /* ColIdOrString: ColId */ + case 114: #line 50 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19632 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 115: /* ColIdOrString: SCONST */ + case 115: #line 51 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19638 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 116: /* Sconst: SCONST */ + case 116: #line 55 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19644 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 117: /* indirection: indirection_el */ + case 117: #line 59 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 19650 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 118: /* indirection: indirection indirection_el */ + case 118: #line 60 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 19656 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 119: /* indirection_el: '.' attr_name */ + case 119: #line 65 "third_party/libpg_query/grammar/statements/common.y" - { - (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); - } -#line 19664 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeString((yyvsp[(2) - (2)].str)); + ;} break; - case 120: /* attr_name: ColLabel */ + case 120: #line 70 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19670 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 121: /* ColLabel: IDENT */ + case 121: #line 75 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19676 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 122: /* ColLabel: other_keyword */ + case 122: #line 76 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 19682 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 123: /* ColLabel: unreserved_keyword */ + case 123: #line 77 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 19688 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 124: /* ColLabel: reserved_keyword */ + case 124: #line 78 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 19694 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 125: /* RenameStmt: ALTER SCHEMA name RENAME TO name */ + case 125: #line 7 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_SCHEMA; - n->subname = (yyvsp[-3].str); - n->newname = (yyvsp[0].str); + n->subname = (yyvsp[(3) - (6)].str); + n->newname = (yyvsp[(6) - (6)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19707 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 126: /* RenameStmt: ALTER TABLE relation_expr RENAME TO name */ + case 126: #line 16 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_TABLE; - n->relation = (yyvsp[-3].range); + n->relation = (yyvsp[(3) - (6)].range); n->subname = NULL; - n->newname = (yyvsp[0].str); + n->newname = (yyvsp[(6) - (6)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19721 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 127: /* RenameStmt: ALTER TABLE IF_P EXISTS relation_expr RENAME TO name */ + case 127: #line 26 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_TABLE; - n->relation = (yyvsp[-3].range); + n->relation = (yyvsp[(5) - (8)].range); n->subname = NULL; - n->newname = (yyvsp[0].str); + n->newname = (yyvsp[(8) - (8)].str); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19735 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 128: /* RenameStmt: ALTER SEQUENCE qualified_name RENAME TO name */ + case 128: #line 36 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_SEQUENCE; - n->relation = (yyvsp[-3].range); + n->relation = (yyvsp[(3) - (6)].range); n->subname = NULL; - n->newname = (yyvsp[0].str); + n->newname = (yyvsp[(6) - (6)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19749 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 129: /* RenameStmt: ALTER SEQUENCE IF_P EXISTS qualified_name RENAME TO name */ + case 129: #line 46 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_SEQUENCE; - n->relation = (yyvsp[-3].range); + n->relation = (yyvsp[(5) - (8)].range); n->subname = NULL; - n->newname = (yyvsp[0].str); + n->newname = (yyvsp[(8) - (8)].str); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19763 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 130: /* RenameStmt: ALTER VIEW qualified_name RENAME TO name */ + case 130: #line 56 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_VIEW; - n->relation = (yyvsp[-3].range); + n->relation = (yyvsp[(3) - (6)].range); n->subname = NULL; - n->newname = (yyvsp[0].str); + n->newname = (yyvsp[(6) - (6)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19777 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 131: /* RenameStmt: ALTER VIEW IF_P EXISTS qualified_name RENAME TO name */ + case 131: #line 66 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_VIEW; - n->relation = (yyvsp[-3].range); + n->relation = (yyvsp[(5) - (8)].range); n->subname = NULL; - n->newname = (yyvsp[0].str); + n->newname = (yyvsp[(8) - (8)].str); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19791 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 132: /* RenameStmt: ALTER INDEX qualified_name RENAME TO name */ + case 132: #line 76 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_INDEX; - n->relation = (yyvsp[-3].range); + n->relation = (yyvsp[(3) - (6)].range); n->subname = NULL; - n->newname = (yyvsp[0].str); + n->newname = (yyvsp[(6) - (6)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19805 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 133: /* RenameStmt: ALTER INDEX IF_P EXISTS qualified_name RENAME TO name */ + case 133: #line 86 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_INDEX; - n->relation = (yyvsp[-3].range); + n->relation = (yyvsp[(5) - (8)].range); n->subname = NULL; - n->newname = (yyvsp[0].str); + n->newname = (yyvsp[(8) - (8)].str); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19819 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 134: /* RenameStmt: ALTER TABLE relation_expr RENAME opt_column name TO name */ + case 134: #line 96 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_COLUMN; n->relationType = PG_OBJECT_TABLE; - n->relation = (yyvsp[-5].range); - n->subname = (yyvsp[-2].str); - n->newname = (yyvsp[0].str); + n->relation = (yyvsp[(3) - (8)].range); + n->subname = (yyvsp[(6) - (8)].str); + n->newname = (yyvsp[(8) - (8)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19834 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 135: /* RenameStmt: ALTER TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name */ + case 135: #line 107 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_COLUMN; n->relationType = PG_OBJECT_TABLE; - n->relation = (yyvsp[-5].range); - n->subname = (yyvsp[-2].str); - n->newname = (yyvsp[0].str); + n->relation = (yyvsp[(5) - (10)].range); + n->subname = (yyvsp[(8) - (10)].str); + n->newname = (yyvsp[(10) - (10)].str); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19849 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 136: /* RenameStmt: ALTER TABLE relation_expr RENAME CONSTRAINT name TO name */ + case 136: #line 118 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_TABCONSTRAINT; - n->relation = (yyvsp[-5].range); - n->subname = (yyvsp[-2].str); - n->newname = (yyvsp[0].str); + n->relation = (yyvsp[(3) - (8)].range); + n->subname = (yyvsp[(6) - (8)].str); + n->newname = (yyvsp[(8) - (8)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 19863 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 137: /* RenameStmt: ALTER TABLE IF_P EXISTS relation_expr RENAME CONSTRAINT name TO name */ + case 137: #line 128 "third_party/libpg_query/grammar/statements/rename.y" - { + { PGRenameStmt *n = makeNode(PGRenameStmt); n->renameType = PG_OBJECT_TABCONSTRAINT; - n->relation = (yyvsp[-5].range); - n->subname = (yyvsp[-2].str); - n->newname = (yyvsp[0].str); + n->relation = (yyvsp[(5) - (10)].range); + n->subname = (yyvsp[(8) - (10)].str); + n->newname = (yyvsp[(10) - (10)].str); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 19877 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 138: /* opt_column: COLUMN */ + case 138: #line 140 "third_party/libpg_query/grammar/statements/rename.y" - { (yyval.ival) = COLUMN; } -#line 19883 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = COLUMN; ;} break; - case 139: /* opt_column: %empty */ + case 139: #line 141 "third_party/libpg_query/grammar/statements/rename.y" - { (yyval.ival) = 0; } -#line 19889 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 140: /* InsertStmt: opt_with_clause INSERT opt_or_action INTO insert_target opt_by_name_or_position insert_rest opt_on_conflict returning_clause */ + case 140: #line 11 "third_party/libpg_query/grammar/statements/insert.y" - { - (yyvsp[-2].istmt)->relation = (yyvsp[-4].range); - (yyvsp[-2].istmt)->onConflictAlias = (yyvsp[-6].onconflictshorthand); - (yyvsp[-2].istmt)->onConflictClause = (yyvsp[-1].onconflict); - (yyvsp[-2].istmt)->returningList = (yyvsp[0].list); - (yyvsp[-2].istmt)->withClause = (yyvsp[-8].with); - (yyvsp[-2].istmt)->insert_column_order = (yyvsp[-3].bynameorposition); - (yyval.node) = (PGNode *) (yyvsp[-2].istmt); - } -#line 19903 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyvsp[(7) - (9)].istmt)->relation = (yyvsp[(5) - (9)].range); + (yyvsp[(7) - (9)].istmt)->onConflictAlias = (yyvsp[(3) - (9)].onconflictshorthand); + (yyvsp[(7) - (9)].istmt)->onConflictClause = (yyvsp[(8) - (9)].onconflict); + (yyvsp[(7) - (9)].istmt)->returningList = (yyvsp[(9) - (9)].list); + (yyvsp[(7) - (9)].istmt)->withClause = (yyvsp[(1) - (9)].with); + (yyvsp[(7) - (9)].istmt)->insert_column_order = (yyvsp[(6) - (9)].bynameorposition); + (yyval.node) = (PGNode *) (yyvsp[(7) - (9)].istmt); + ;} break; - case 141: /* insert_rest: SelectStmt */ + case 141: #line 24 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.istmt) = makeNode(PGInsertStmt); (yyval.istmt)->cols = NIL; - (yyval.istmt)->selectStmt = (yyvsp[0].node); - } -#line 19913 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.istmt)->selectStmt = (yyvsp[(1) - (1)].node); + ;} break; - case 142: /* insert_rest: OVERRIDING override_kind VALUE_P SelectStmt */ + case 142: #line 30 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.istmt) = makeNode(PGInsertStmt); (yyval.istmt)->cols = NIL; - (yyval.istmt)->override = (yyvsp[-2].override); - (yyval.istmt)->selectStmt = (yyvsp[0].node); - } -#line 19924 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.istmt)->override = (yyvsp[(2) - (4)].override); + (yyval.istmt)->selectStmt = (yyvsp[(4) - (4)].node); + ;} break; - case 143: /* insert_rest: '(' insert_column_list ')' SelectStmt */ + case 143: #line 37 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.istmt) = makeNode(PGInsertStmt); - (yyval.istmt)->cols = (yyvsp[-2].list); - (yyval.istmt)->selectStmt = (yyvsp[0].node); - } -#line 19934 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.istmt)->cols = (yyvsp[(2) - (4)].list); + (yyval.istmt)->selectStmt = (yyvsp[(4) - (4)].node); + ;} break; - case 144: /* insert_rest: '(' insert_column_list ')' OVERRIDING override_kind VALUE_P SelectStmt */ + case 144: #line 43 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.istmt) = makeNode(PGInsertStmt); - (yyval.istmt)->cols = (yyvsp[-5].list); - (yyval.istmt)->override = (yyvsp[-2].override); - (yyval.istmt)->selectStmt = (yyvsp[0].node); - } -#line 19945 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.istmt)->cols = (yyvsp[(2) - (7)].list); + (yyval.istmt)->override = (yyvsp[(5) - (7)].override); + (yyval.istmt)->selectStmt = (yyvsp[(7) - (7)].node); + ;} break; - case 145: /* insert_rest: DEFAULT VALUES */ + case 145: #line 50 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.istmt) = makeNode(PGInsertStmt); (yyval.istmt)->cols = NIL; (yyval.istmt)->selectStmt = NULL; - } -#line 19955 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 146: /* insert_target: qualified_name */ + case 146: #line 60 "third_party/libpg_query/grammar/statements/insert.y" - { - (yyval.range) = (yyvsp[0].range); - } -#line 19963 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.range) = (yyvsp[(1) - (1)].range); + ;} break; - case 147: /* insert_target: qualified_name AS ColId */ + case 147: #line 64 "third_party/libpg_query/grammar/statements/insert.y" - { - (yyvsp[-2].range)->alias = makeAlias((yyvsp[0].str), NIL); - (yyval.range) = (yyvsp[-2].range); - } -#line 19972 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyvsp[(1) - (3)].range)->alias = makeAlias((yyvsp[(3) - (3)].str), NIL); + (yyval.range) = (yyvsp[(1) - (3)].range); + ;} break; - case 148: /* opt_by_name_or_position: BY NAME_P */ + case 148: #line 71 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.bynameorposition) = PG_INSERT_BY_NAME; } -#line 19978 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.bynameorposition) = PG_INSERT_BY_NAME; ;} break; - case 149: /* opt_by_name_or_position: BY POSITION */ + case 149: #line 72 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.bynameorposition) = PG_INSERT_BY_POSITION; } -#line 19984 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.bynameorposition) = PG_INSERT_BY_POSITION; ;} break; - case 150: /* opt_by_name_or_position: %empty */ + case 150: #line 73 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.bynameorposition) = PG_INSERT_BY_POSITION; } -#line 19990 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.bynameorposition) = PG_INSERT_BY_POSITION; ;} break; - case 151: /* opt_conf_expr: '(' index_params ')' where_clause */ + case 151: #line 78 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.infer) = makeNode(PGInferClause); - (yyval.infer)->indexElems = (yyvsp[-2].list); - (yyval.infer)->whereClause = (yyvsp[0].node); + (yyval.infer)->indexElems = (yyvsp[(2) - (4)].list); + (yyval.infer)->whereClause = (yyvsp[(4) - (4)].node); (yyval.infer)->conname = NULL; - (yyval.infer)->location = (yylsp[-3]); - } -#line 20002 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.infer)->location = (yylsp[(1) - (4)]); + ;} break; - case 152: /* opt_conf_expr: ON CONSTRAINT name */ + case 152: #line 87 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.infer) = makeNode(PGInferClause); (yyval.infer)->indexElems = NIL; (yyval.infer)->whereClause = NULL; - (yyval.infer)->conname = (yyvsp[0].str); - (yyval.infer)->location = (yylsp[-2]); - } -#line 20014 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.infer)->conname = (yyvsp[(3) - (3)].str); + (yyval.infer)->location = (yylsp[(1) - (3)]); + ;} break; - case 153: /* opt_conf_expr: %empty */ + case 153: #line 95 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.infer) = NULL; - } -#line 20022 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 154: /* opt_with_clause: with_clause */ + case 154: #line 102 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.with) = (yyvsp[0].with); } -#line 20028 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.with) = (yyvsp[(1) - (1)].with); ;} break; - case 155: /* opt_with_clause: %empty */ + case 155: #line 103 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.with) = NULL; } -#line 20034 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.with) = NULL; ;} break; - case 156: /* insert_column_item: ColId opt_indirection */ + case 156: #line 109 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.target) = makeNode(PGResTarget); - (yyval.target)->name = (yyvsp[-1].str); - (yyval.target)->indirection = check_indirection((yyvsp[0].list), yyscanner); + (yyval.target)->name = (yyvsp[(1) - (2)].str); + (yyval.target)->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner); (yyval.target)->val = NULL; - (yyval.target)->location = (yylsp[-1]); - } -#line 20046 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.target)->location = (yylsp[(1) - (2)]); + ;} break; - case 157: /* set_clause: set_target '=' a_expr */ + case 157: #line 121 "third_party/libpg_query/grammar/statements/insert.y" - { - (yyvsp[-2].target)->val = (PGNode *) (yyvsp[0].node); - (yyval.list) = list_make1((yyvsp[-2].target)); - } -#line 20055 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyvsp[(1) - (3)].target)->val = (PGNode *) (yyvsp[(3) - (3)].node); + (yyval.list) = list_make1((yyvsp[(1) - (3)].target)); + ;} break; - case 158: /* set_clause: '(' set_target_list ')' '=' a_expr */ + case 158: #line 126 "third_party/libpg_query/grammar/statements/insert.y" - { - int ncolumns = list_length((yyvsp[-3].list)); + { + int ncolumns = list_length((yyvsp[(2) - (5)].list)); int i = 1; PGListCell *col_cell; /* Create a PGMultiAssignRef source for each target */ - foreach(col_cell, (yyvsp[-3].list)) + foreach(col_cell, (yyvsp[(2) - (5)].list)) { PGResTarget *res_col = (PGResTarget *) lfirst(col_cell); PGMultiAssignRef *r = makeNode(PGMultiAssignRef); - r->source = (PGNode *) (yyvsp[0].node); + r->source = (PGNode *) (yyvsp[(5) - (5)].node); r->colno = i; r->ncolumns = ncolumns; res_col->val = (PGNode *) r; i++; } - (yyval.list) = (yyvsp[-3].list); - } -#line 20080 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.list) = (yyvsp[(2) - (5)].list); + ;} break; - case 159: /* opt_or_action: OR REPLACE */ + case 159: #line 151 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.onconflictshorthand) = PG_ONCONFLICT_ALIAS_REPLACE; - } -#line 20088 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 160: /* opt_or_action: OR IGNORE_P */ + case 160: #line 156 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.onconflictshorthand) = PG_ONCONFLICT_ALIAS_IGNORE; - } -#line 20096 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 161: /* opt_or_action: %empty */ + case 161: #line 160 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.onconflictshorthand) = PG_ONCONFLICT_ALIAS_NONE; - } -#line 20104 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 162: /* opt_on_conflict: ON CONFLICT opt_conf_expr DO UPDATE SET set_clause_list_opt_comma where_clause */ + case 162: #line 167 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.onconflict) = makeNode(PGOnConflictClause); (yyval.onconflict)->action = PG_ONCONFLICT_UPDATE; - (yyval.onconflict)->infer = (yyvsp[-5].infer); - (yyval.onconflict)->targetList = (yyvsp[-1].list); - (yyval.onconflict)->whereClause = (yyvsp[0].node); - (yyval.onconflict)->location = (yylsp[-7]); - } -#line 20117 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.onconflict)->infer = (yyvsp[(3) - (8)].infer); + (yyval.onconflict)->targetList = (yyvsp[(7) - (8)].list); + (yyval.onconflict)->whereClause = (yyvsp[(8) - (8)].node); + (yyval.onconflict)->location = (yylsp[(1) - (8)]); + ;} break; - case 163: /* opt_on_conflict: ON CONFLICT opt_conf_expr DO NOTHING */ + case 163: #line 177 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.onconflict) = makeNode(PGOnConflictClause); (yyval.onconflict)->action = PG_ONCONFLICT_NOTHING; - (yyval.onconflict)->infer = (yyvsp[-2].infer); + (yyval.onconflict)->infer = (yyvsp[(3) - (5)].infer); (yyval.onconflict)->targetList = NIL; (yyval.onconflict)->whereClause = NULL; - (yyval.onconflict)->location = (yylsp[-4]); - } -#line 20130 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.onconflict)->location = (yylsp[(1) - (5)]); + ;} break; - case 164: /* opt_on_conflict: %empty */ + case 164: #line 186 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.onconflict) = NULL; - } -#line 20138 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 165: /* index_elem: ColId opt_collate opt_class opt_asc_desc opt_nulls_order */ + case 165: #line 193 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.ielem) = makeNode(PGIndexElem); - (yyval.ielem)->name = (yyvsp[-4].str); + (yyval.ielem)->name = (yyvsp[(1) - (5)].str); (yyval.ielem)->expr = NULL; (yyval.ielem)->indexcolname = NULL; - (yyval.ielem)->collation = (yyvsp[-3].list); - (yyval.ielem)->opclass = (yyvsp[-2].list); - (yyval.ielem)->ordering = (yyvsp[-1].sortorder); - (yyval.ielem)->nulls_ordering = (yyvsp[0].nullorder); - } -#line 20153 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.ielem)->collation = (yyvsp[(2) - (5)].list); + (yyval.ielem)->opclass = (yyvsp[(3) - (5)].list); + (yyval.ielem)->ordering = (yyvsp[(4) - (5)].sortorder); + (yyval.ielem)->nulls_ordering = (yyvsp[(5) - (5)].nullorder); + ;} break; - case 166: /* index_elem: func_expr_windowless opt_collate opt_class opt_asc_desc opt_nulls_order */ + case 166: #line 204 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.ielem) = makeNode(PGIndexElem); (yyval.ielem)->name = NULL; - (yyval.ielem)->expr = (yyvsp[-4].node); + (yyval.ielem)->expr = (yyvsp[(1) - (5)].node); (yyval.ielem)->indexcolname = NULL; - (yyval.ielem)->collation = (yyvsp[-3].list); - (yyval.ielem)->opclass = (yyvsp[-2].list); - (yyval.ielem)->ordering = (yyvsp[-1].sortorder); - (yyval.ielem)->nulls_ordering = (yyvsp[0].nullorder); - } -#line 20168 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.ielem)->collation = (yyvsp[(2) - (5)].list); + (yyval.ielem)->opclass = (yyvsp[(3) - (5)].list); + (yyval.ielem)->ordering = (yyvsp[(4) - (5)].sortorder); + (yyval.ielem)->nulls_ordering = (yyvsp[(5) - (5)].nullorder); + ;} break; - case 167: /* index_elem: '(' a_expr ')' opt_collate opt_class opt_asc_desc opt_nulls_order */ + case 167: #line 215 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.ielem) = makeNode(PGIndexElem); (yyval.ielem)->name = NULL; - (yyval.ielem)->expr = (yyvsp[-5].node); + (yyval.ielem)->expr = (yyvsp[(2) - (7)].node); (yyval.ielem)->indexcolname = NULL; - (yyval.ielem)->collation = (yyvsp[-3].list); - (yyval.ielem)->opclass = (yyvsp[-2].list); - (yyval.ielem)->ordering = (yyvsp[-1].sortorder); - (yyval.ielem)->nulls_ordering = (yyvsp[0].nullorder); - } -#line 20183 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.ielem)->collation = (yyvsp[(4) - (7)].list); + (yyval.ielem)->opclass = (yyvsp[(5) - (7)].list); + (yyval.ielem)->ordering = (yyvsp[(6) - (7)].sortorder); + (yyval.ielem)->nulls_ordering = (yyvsp[(7) - (7)].nullorder); + ;} break; - case 168: /* returning_clause: RETURNING target_list */ + case 168: #line 229 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20189 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 169: /* returning_clause: %empty */ + case 169: #line 230 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = NIL; } -#line 20195 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 170: /* override_kind: USER */ + case 170: #line 236 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.override) = PG_OVERRIDING_USER_VALUE; } -#line 20201 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.override) = PG_OVERRIDING_USER_VALUE; ;} break; - case 171: /* override_kind: SYSTEM_P */ + case 171: #line 237 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.override) = OVERRIDING_SYSTEM_VALUE; } -#line 20207 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.override) = OVERRIDING_SYSTEM_VALUE; ;} break; - case 172: /* set_target_list: set_target */ + case 172: #line 242 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = list_make1((yyvsp[0].target)); } -#line 20213 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} break; - case 173: /* set_target_list: set_target_list ',' set_target */ + case 173: #line 243 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = lappend((yyvsp[-2].list),(yyvsp[0].target)); } -#line 20219 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].target)); ;} break; - case 174: /* opt_collate: COLLATE any_name */ + case 174: #line 249 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20225 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 175: /* opt_collate: %empty */ + case 175: #line 250 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = NIL; } -#line 20231 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 176: /* opt_class: any_name */ + case 176: #line 254 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20237 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 177: /* opt_class: %empty */ + case 177: #line 255 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = NIL; } -#line 20243 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 178: /* insert_column_list: insert_column_item */ + case 178: #line 261 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = list_make1((yyvsp[0].target)); } -#line 20249 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} break; - case 179: /* insert_column_list: insert_column_list ',' insert_column_item */ + case 179: #line 263 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].target)); } -#line 20255 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;} break; - case 180: /* set_clause_list: set_clause */ + case 180: #line 268 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20261 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 181: /* set_clause_list: set_clause_list ',' set_clause */ + case 181: #line 269 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = list_concat((yyvsp[-2].list),(yyvsp[0].list)); } -#line 20267 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_concat((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].list)); ;} break; - case 182: /* set_clause_list_opt_comma: set_clause_list */ + case 182: #line 273 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20273 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 183: /* set_clause_list_opt_comma: set_clause_list ',' */ + case 183: #line 274 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 20279 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 184: /* index_params: index_elem */ + case 184: #line 277 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = list_make1((yyvsp[0].ielem)); } -#line 20285 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].ielem)); ;} break; - case 185: /* index_params: index_params ',' index_elem */ + case 185: #line 278 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].ielem)); } -#line 20291 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].ielem)); ;} break; - case 186: /* set_target: ColId opt_indirection */ + case 186: #line 284 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.target) = makeNode(PGResTarget); - (yyval.target)->name = (yyvsp[-1].str); - (yyval.target)->indirection = check_indirection((yyvsp[0].list), yyscanner); + (yyval.target)->name = (yyvsp[(1) - (2)].str); + (yyval.target)->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner); (yyval.target)->val = NULL; /* upper production sets this */ - (yyval.target)->location = (yylsp[-1]); - } -#line 20303 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.target)->location = (yylsp[(1) - (2)]); + ;} break; - case 187: /* CreateTypeStmt: CREATE_P TYPE_P qualified_name AS ENUM_P select_with_parens */ + case 187: #line 8 "third_party/libpg_query/grammar/statements/create_type.y" - { + { PGCreateTypeStmt *n = makeNode(PGCreateTypeStmt); - n->typeName = (yyvsp[-3].range); + n->typeName = (yyvsp[(3) - (6)].range); n->kind = PG_NEWTYPE_ENUM; - n->query = (yyvsp[0].node); + n->query = (yyvsp[(6) - (6)].node); n->vals = NULL; (yyval.node) = (PGNode *)n; - } -#line 20316 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 188: /* CreateTypeStmt: CREATE_P TYPE_P qualified_name AS ENUM_P '(' opt_enum_val_list ')' */ + case 188: #line 17 "third_party/libpg_query/grammar/statements/create_type.y" - { + { PGCreateTypeStmt *n = makeNode(PGCreateTypeStmt); - n->typeName = (yyvsp[-5].range); + n->typeName = (yyvsp[(3) - (8)].range); n->kind = PG_NEWTYPE_ENUM; - n->vals = (yyvsp[-1].list); + n->vals = (yyvsp[(7) - (8)].list); n->query = NULL; (yyval.node) = (PGNode *)n; - } -#line 20329 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 189: /* CreateTypeStmt: CREATE_P TYPE_P qualified_name AS Typename */ + case 189: #line 26 "third_party/libpg_query/grammar/statements/create_type.y" - { + { PGCreateTypeStmt *n = makeNode(PGCreateTypeStmt); - n->typeName = (yyvsp[-2].range); + n->typeName = (yyvsp[(3) - (5)].range); n->query = NULL; - auto name = std::string(reinterpret_cast((yyvsp[0].typnam)->names->tail->data.ptr_value)->val.str); + auto name = std::string(reinterpret_cast((yyvsp[(5) - (5)].typnam)->names->tail->data.ptr_value)->val.str); if (name == "enum") { n->kind = PG_NEWTYPE_ENUM; - n->vals = (yyvsp[0].typnam)->typmods; + n->vals = (yyvsp[(5) - (5)].typnam)->typmods; } else { n->kind = PG_NEWTYPE_ALIAS; - n->ofType = (yyvsp[0].typnam); + n->ofType = (yyvsp[(5) - (5)].typnam); } (yyval.node) = (PGNode *)n; - } -#line 20348 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 190: /* opt_enum_val_list: enum_val_list */ + case 190: #line 46 "third_party/libpg_query/grammar/statements/create_type.y" - { (yyval.list) = (yyvsp[0].list);} -#line 20354 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list);;} break; - case 191: /* opt_enum_val_list: %empty */ + case 191: #line 47 "third_party/libpg_query/grammar/statements/create_type.y" - {(yyval.list) = NIL;} -#line 20360 "third_party/libpg_query/grammar/grammar_out.cpp" + {(yyval.list) = NIL;;} break; - case 192: /* enum_val_list: Sconst */ + case 192: #line 51 "third_party/libpg_query/grammar/statements/create_type.y" - { - (yyval.list) = list_make1(makeStringConst((yyvsp[0].str), (yylsp[0]))); - } -#line 20368 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1(makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]))); + ;} break; - case 193: /* enum_val_list: enum_val_list ',' Sconst */ + case 193: #line 55 "third_party/libpg_query/grammar/statements/create_type.y" - { - (yyval.list) = lappend((yyvsp[-2].list), makeStringConst((yyvsp[0].str), (yylsp[0]))); - } -#line 20376 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeStringConst((yyvsp[(3) - (3)].str), (yylsp[(3) - (3)]))); + ;} break; - case 194: /* PragmaStmt: PRAGMA_P ColId */ + case 194: #line 8 "third_party/libpg_query/grammar/statements/pragma.y" - { + { PGPragmaStmt *n = makeNode(PGPragmaStmt); n->kind = PG_PRAGMA_TYPE_NOTHING; - n->name = (yyvsp[0].str); + n->name = (yyvsp[(2) - (2)].str); (yyval.node) = (PGNode *)n; - } -#line 20387 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 195: /* PragmaStmt: PRAGMA_P ColId '=' var_list */ + case 195: #line 15 "third_party/libpg_query/grammar/statements/pragma.y" - { + { PGPragmaStmt *n = makeNode(PGPragmaStmt); n->kind = PG_PRAGMA_TYPE_ASSIGNMENT; - n->name = (yyvsp[-2].str); - n->args = (yyvsp[0].list); + n->name = (yyvsp[(2) - (4)].str); + n->args = (yyvsp[(4) - (4)].list); (yyval.node) = (PGNode *)n; - } -#line 20399 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 196: /* PragmaStmt: PRAGMA_P ColId '(' func_arg_list ')' */ + case 196: #line 23 "third_party/libpg_query/grammar/statements/pragma.y" - { + { PGPragmaStmt *n = makeNode(PGPragmaStmt); n->kind = PG_PRAGMA_TYPE_CALL; - n->name = (yyvsp[-3].str); - n->args = (yyvsp[-1].list); + n->name = (yyvsp[(2) - (5)].str); + n->args = (yyvsp[(4) - (5)].list); (yyval.node) = (PGNode *)n; - } -#line 20411 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 197: /* CreateSeqStmt: CREATE_P OptTemp SEQUENCE qualified_name OptSeqOptList */ + case 197: #line 10 "third_party/libpg_query/grammar/statements/create_sequence.y" - { + { PGCreateSeqStmt *n = makeNode(PGCreateSeqStmt); - (yyvsp[-1].range)->relpersistence = (yyvsp[-3].ival); - n->sequence = (yyvsp[-1].range); - n->options = (yyvsp[0].list); + (yyvsp[(4) - (5)].range)->relpersistence = (yyvsp[(2) - (5)].ival); + n->sequence = (yyvsp[(4) - (5)].range); + n->options = (yyvsp[(5) - (5)].list); n->ownerId = InvalidOid; n->onconflict = PG_ERROR_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 20425 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 198: /* CreateSeqStmt: CREATE_P OptTemp SEQUENCE IF_P NOT EXISTS qualified_name OptSeqOptList */ + case 198: #line 20 "third_party/libpg_query/grammar/statements/create_sequence.y" - { + { PGCreateSeqStmt *n = makeNode(PGCreateSeqStmt); - (yyvsp[-1].range)->relpersistence = (yyvsp[-6].ival); - n->sequence = (yyvsp[-1].range); - n->options = (yyvsp[0].list); + (yyvsp[(7) - (8)].range)->relpersistence = (yyvsp[(2) - (8)].ival); + n->sequence = (yyvsp[(7) - (8)].range); + n->options = (yyvsp[(8) - (8)].list); n->ownerId = InvalidOid; n->onconflict = PG_IGNORE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 20439 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 199: /* CreateSeqStmt: CREATE_P OR REPLACE OptTemp SEQUENCE qualified_name OptSeqOptList */ + case 199: #line 30 "third_party/libpg_query/grammar/statements/create_sequence.y" - { + { PGCreateSeqStmt *n = makeNode(PGCreateSeqStmt); - (yyvsp[-1].range)->relpersistence = (yyvsp[-3].ival); - n->sequence = (yyvsp[-1].range); - n->options = (yyvsp[0].list); + (yyvsp[(6) - (7)].range)->relpersistence = (yyvsp[(4) - (7)].ival); + n->sequence = (yyvsp[(6) - (7)].range); + n->options = (yyvsp[(7) - (7)].list); n->ownerId = InvalidOid; n->onconflict = PG_REPLACE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 20453 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 200: /* OptSeqOptList: SeqOptList */ + case 200: #line 42 "third_party/libpg_query/grammar/statements/create_sequence.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20459 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 201: /* OptSeqOptList: %empty */ + case 201: #line 43 "third_party/libpg_query/grammar/statements/create_sequence.y" - { (yyval.list) = NIL; } -#line 20465 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 202: /* CreateSecretStmt: CREATE_P opt_persist SECRET opt_secret_name opt_storage_specifier '(' copy_generic_opt_list ')' */ + case 202: #line 8 "third_party/libpg_query/grammar/statements/create_secret.y" - { + { PGCreateSecretStmt *n = makeNode(PGCreateSecretStmt); - n->persist_type = (yyvsp[-6].str); - n->secret_name = (yyvsp[-4].str); - n->secret_storage = (yyvsp[-3].str); - n->options = (yyvsp[-1].list); + n->persist_type = (yyvsp[(2) - (8)].str); + n->secret_name = (yyvsp[(4) - (8)].str); + n->secret_storage = (yyvsp[(5) - (8)].str); + n->options = (yyvsp[(7) - (8)].list); n->onconflict = PG_ERROR_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 20479 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 203: /* CreateSecretStmt: CREATE_P opt_persist SECRET IF_P NOT EXISTS opt_secret_name opt_storage_specifier '(' copy_generic_opt_list ')' */ + case 203: #line 18 "third_party/libpg_query/grammar/statements/create_secret.y" - { + { PGCreateSecretStmt *n = makeNode(PGCreateSecretStmt); - n->persist_type = (yyvsp[-9].str); - n->secret_name = (yyvsp[-4].str); - n->secret_storage = (yyvsp[-3].str); - n->options = (yyvsp[-1].list); + n->persist_type = (yyvsp[(2) - (11)].str); + n->secret_name = (yyvsp[(7) - (11)].str); + n->secret_storage = (yyvsp[(8) - (11)].str); + n->options = (yyvsp[(10) - (11)].list); n->onconflict = PG_IGNORE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 20493 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 204: /* CreateSecretStmt: CREATE_P OR REPLACE opt_persist SECRET opt_secret_name opt_storage_specifier '(' copy_generic_opt_list ')' */ + case 204: #line 28 "third_party/libpg_query/grammar/statements/create_secret.y" - { + { PGCreateSecretStmt *n = makeNode(PGCreateSecretStmt); - n->persist_type = (yyvsp[-6].str); - n->secret_name = (yyvsp[-4].str); - n->secret_storage = (yyvsp[-3].str); - n->options = (yyvsp[-1].list); + n->persist_type = (yyvsp[(4) - (10)].str); + n->secret_name = (yyvsp[(6) - (10)].str); + n->secret_storage = (yyvsp[(7) - (10)].str); + n->options = (yyvsp[(9) - (10)].list); n->onconflict = PG_REPLACE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 20507 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 205: /* opt_secret_name: %empty */ + case 205: #line 40 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = NULL; } -#line 20513 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 206: /* opt_secret_name: ColId */ + case 206: #line 41 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = (yyvsp[0].str); } -#line 20519 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 207: /* opt_persist: %empty */ + case 207: #line 45 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = pstrdup("default"); } -#line 20525 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup("default"); ;} break; - case 208: /* opt_persist: TEMPORARY */ + case 208: #line 46 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = pstrdup("temporary"); } -#line 20531 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup("temporary"); ;} break; - case 209: /* opt_persist: PERSISTENT */ + case 209: #line 47 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = pstrdup("persistent"); } -#line 20537 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup("persistent"); ;} break; - case 210: /* opt_storage_specifier: %empty */ + case 210: #line 51 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = pstrdup(""); } -#line 20543 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup(""); ;} break; - case 211: /* opt_storage_specifier: IN_P IDENT */ + case 211: #line 52 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = (yyvsp[0].str); } -#line 20549 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 212: /* ExecuteStmt: EXECUTE name execute_param_clause */ + case 212: #line 8 "third_party/libpg_query/grammar/statements/execute.y" - { + { PGExecuteStmt *n = makeNode(PGExecuteStmt); - n->name = (yyvsp[-1].str); - n->params = (yyvsp[0].list); + n->name = (yyvsp[(2) - (3)].str); + n->params = (yyvsp[(3) - (3)].list); (yyval.node) = (PGNode *) n; - } -#line 20560 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 213: /* ExecuteStmt: CREATE_P OptTemp TABLE create_as_target AS EXECUTE name execute_param_clause opt_with_data */ + case 213: #line 16 "third_party/libpg_query/grammar/statements/execute.y" - { + { PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt); PGExecuteStmt *n = makeNode(PGExecuteStmt); - n->name = (yyvsp[-2].str); - n->params = (yyvsp[-1].list); + n->name = (yyvsp[(7) - (9)].str); + n->params = (yyvsp[(8) - (9)].list); ctas->query = (PGNode *) n; - ctas->into = (yyvsp[-5].into); + ctas->into = (yyvsp[(4) - (9)].into); ctas->relkind = PG_OBJECT_TABLE; ctas->is_select_into = false; ctas->onconflict = PG_ERROR_ON_CONFLICT; /* cram additional flags into the PGIntoClause */ - (yyvsp[-5].into)->rel->relpersistence = (yyvsp[-7].ival); - (yyvsp[-5].into)->skipData = !((yyvsp[0].boolean)); + (yyvsp[(4) - (9)].into)->rel->relpersistence = (yyvsp[(2) - (9)].ival); + (yyvsp[(4) - (9)].into)->skipData = !((yyvsp[(9) - (9)].boolean)); (yyval.node) = (PGNode *) ctas; - } -#line 20580 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 214: /* ExecuteStmt: CREATE_P OptTemp TABLE IF_P NOT EXISTS create_as_target AS EXECUTE name execute_param_clause opt_with_data */ + case 214: #line 33 "third_party/libpg_query/grammar/statements/execute.y" - { + { PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt); PGExecuteStmt *n = makeNode(PGExecuteStmt); - n->name = (yyvsp[-2].str); - n->params = (yyvsp[-1].list); + n->name = (yyvsp[(10) - (12)].str); + n->params = (yyvsp[(11) - (12)].list); ctas->query = (PGNode *) n; - ctas->into = (yyvsp[-5].into); + ctas->into = (yyvsp[(7) - (12)].into); ctas->relkind = PG_OBJECT_TABLE; ctas->is_select_into = false; ctas->onconflict = PG_IGNORE_ON_CONFLICT; /* cram additional flags into the PGIntoClause */ - (yyvsp[-5].into)->rel->relpersistence = (yyvsp[-10].ival); - (yyvsp[-5].into)->skipData = !((yyvsp[0].boolean)); + (yyvsp[(7) - (12)].into)->rel->relpersistence = (yyvsp[(2) - (12)].ival); + (yyvsp[(7) - (12)].into)->skipData = !((yyvsp[(12) - (12)].boolean)); (yyval.node) = (PGNode *) ctas; - } -#line 20600 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 215: /* execute_param_expr: a_expr */ + case 215: #line 52 "third_party/libpg_query/grammar/statements/execute.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 20608 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 216: /* execute_param_expr: param_name COLON_EQUALS a_expr */ + case 216: #line 56 "third_party/libpg_query/grammar/statements/execute.y" - { + { PGNamedArgExpr *na = makeNode(PGNamedArgExpr); - na->name = (yyvsp[-2].str); - na->arg = (PGExpr *) (yyvsp[0].node); + na->name = (yyvsp[(1) - (3)].str); + na->arg = (PGExpr *) (yyvsp[(3) - (3)].node); na->argnumber = -1; /* until determined */ - na->location = (yylsp[-2]); + na->location = (yylsp[(1) - (3)]); (yyval.node) = (PGNode *) na; - } -#line 20621 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 217: /* execute_param_list: execute_param_expr */ + case 217: #line 66 "third_party/libpg_query/grammar/statements/execute.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 20629 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 218: /* execute_param_list: execute_param_list ',' execute_param_expr */ + case 218: #line 70 "third_party/libpg_query/grammar/statements/execute.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 20637 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 219: /* execute_param_clause: '(' execute_param_list ')' */ + case 219: #line 75 "third_party/libpg_query/grammar/statements/execute.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 20643 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 220: /* execute_param_clause: %empty */ + case 220: #line 76 "third_party/libpg_query/grammar/statements/execute.y" - { (yyval.list) = NIL; } -#line 20649 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 221: /* AlterSeqStmt: ALTER SEQUENCE qualified_name SeqOptList */ + case 221: #line 10 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { + { PGAlterSeqStmt *n = makeNode(PGAlterSeqStmt); - n->sequence = (yyvsp[-1].range); - n->options = (yyvsp[0].list); + n->sequence = (yyvsp[(3) - (4)].range); + n->options = (yyvsp[(4) - (4)].list); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 20661 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 222: /* AlterSeqStmt: ALTER SEQUENCE IF_P EXISTS qualified_name SeqOptList */ + case 222: #line 18 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { + { PGAlterSeqStmt *n = makeNode(PGAlterSeqStmt); - n->sequence = (yyvsp[-1].range); - n->options = (yyvsp[0].list); + n->sequence = (yyvsp[(5) - (6)].range); + n->options = (yyvsp[(6) - (6)].list); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 20673 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 223: /* SeqOptList: SeqOptElem */ + case 223: #line 29 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.list) = list_make1((yyvsp[0].defelt)); } -#line 20679 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; - case 224: /* SeqOptList: SeqOptList SeqOptElem */ + case 224: #line 30 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].defelt)); } -#line 20685 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} break; - case 225: /* opt_with: WITH */ + case 225: #line 34 "third_party/libpg_query/grammar/statements/alter_sequence.y" - {} -#line 20691 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 226: /* opt_with: WITH_LA */ + case 226: #line 35 "third_party/libpg_query/grammar/statements/alter_sequence.y" - {} -#line 20697 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 227: /* opt_with: %empty */ + case 227: #line 36 "third_party/libpg_query/grammar/statements/alter_sequence.y" - {} -#line 20703 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 228: /* NumericOnly: FCONST */ + case 228: #line 41 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.value) = makeFloat((yyvsp[0].str)); } -#line 20709 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.value) = makeFloat((yyvsp[(1) - (1)].str)); ;} break; - case 229: /* NumericOnly: '+' FCONST */ + case 229: #line 42 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.value) = makeFloat((yyvsp[0].str)); } -#line 20715 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.value) = makeFloat((yyvsp[(2) - (2)].str)); ;} break; - case 230: /* NumericOnly: '-' FCONST */ + case 230: #line 44 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.value) = makeFloat((yyvsp[0].str)); + { + (yyval.value) = makeFloat((yyvsp[(2) - (2)].str)); doNegateFloat((yyval.value)); - } -#line 20724 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 231: /* NumericOnly: SignedIconst */ + case 231: #line 48 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.value) = makeInteger((yyvsp[0].ival)); } -#line 20730 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.value) = makeInteger((yyvsp[(1) - (1)].ival)); ;} break; - case 232: /* SeqOptElem: AS SimpleTypename */ + case 232: #line 53 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("as", (PGNode *)(yyvsp[0].typnam), (yylsp[-1])); - } -#line 20738 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("as", (PGNode *)(yyvsp[(2) - (2)].typnam), (yylsp[(1) - (2)])); + ;} break; - case 233: /* SeqOptElem: CACHE NumericOnly */ + case 233: #line 57 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("cache", (PGNode *)(yyvsp[0].value), (yylsp[-1])); - } -#line 20746 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("cache", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)])); + ;} break; - case 234: /* SeqOptElem: CYCLE */ + case 234: #line 61 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(true), (yylsp[0])); - } -#line 20754 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(true), (yylsp[(1) - (1)])); + ;} break; - case 235: /* SeqOptElem: NO CYCLE */ + case 235: #line 65 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(false), (yylsp[-1])); - } -#line 20762 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(false), (yylsp[(1) - (2)])); + ;} break; - case 236: /* SeqOptElem: INCREMENT opt_by NumericOnly */ + case 236: #line 69 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("increment", (PGNode *)(yyvsp[0].value), (yylsp[-2])); - } -#line 20770 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("increment", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)])); + ;} break; - case 237: /* SeqOptElem: MAXVALUE NumericOnly */ + case 237: #line 73 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("maxvalue", (PGNode *)(yyvsp[0].value), (yylsp[-1])); - } -#line 20778 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("maxvalue", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)])); + ;} break; - case 238: /* SeqOptElem: MINVALUE NumericOnly */ + case 238: #line 77 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("minvalue", (PGNode *)(yyvsp[0].value), (yylsp[-1])); - } -#line 20786 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("minvalue", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)])); + ;} break; - case 239: /* SeqOptElem: NO MAXVALUE */ + case 239: #line 81 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("maxvalue", NULL, (yylsp[-1])); - } -#line 20794 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("maxvalue", NULL, (yylsp[(1) - (2)])); + ;} break; - case 240: /* SeqOptElem: NO MINVALUE */ + case 240: #line 85 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("minvalue", NULL, (yylsp[-1])); - } -#line 20802 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("minvalue", NULL, (yylsp[(1) - (2)])); + ;} break; - case 241: /* SeqOptElem: OWNED BY any_name */ + case 241: #line 89 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("owned_by", (PGNode *)(yyvsp[0].list), (yylsp[-2])); - } -#line 20810 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("owned_by", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); + ;} break; - case 242: /* SeqOptElem: SEQUENCE NAME_P any_name */ + case 242: #line 93 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { + { /* not documented, only used by pg_dump */ - (yyval.defelt) = makeDefElem("sequence_name", (PGNode *)(yyvsp[0].list), (yylsp[-2])); - } -#line 20819 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.defelt) = makeDefElem("sequence_name", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); + ;} break; - case 243: /* SeqOptElem: START opt_with NumericOnly */ + case 243: #line 98 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("start", (PGNode *)(yyvsp[0].value), (yylsp[-2])); - } -#line 20827 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("start", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)])); + ;} break; - case 244: /* SeqOptElem: RESTART */ + case 244: #line 102 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("restart", NULL, (yylsp[0])); - } -#line 20835 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("restart", NULL, (yylsp[(1) - (1)])); + ;} break; - case 245: /* SeqOptElem: RESTART opt_with NumericOnly */ + case 245: #line 106 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[0].value), (yylsp[-2])); - } -#line 20843 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)])); + ;} break; - case 246: /* opt_by: BY */ + case 246: #line 112 "third_party/libpg_query/grammar/statements/alter_sequence.y" - {} -#line 20849 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 247: /* opt_by: %empty */ + case 247: #line 113 "third_party/libpg_query/grammar/statements/alter_sequence.y" - {} -#line 20855 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 248: /* SignedIconst: Iconst */ + case 248: #line 117 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.ival) = (yyvsp[0].ival); } -#line 20861 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} break; - case 249: /* SignedIconst: '+' Iconst */ + case 249: #line 118 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.ival) = + (yyvsp[0].ival); } -#line 20867 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = + (yyvsp[(2) - (2)].ival); ;} break; - case 250: /* SignedIconst: '-' Iconst */ + case 250: #line 119 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.ival) = - (yyvsp[0].ival); } -#line 20873 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = - (yyvsp[(2) - (2)].ival); ;} break; - case 251: /* DropSecretStmt: DROP opt_persist SECRET ColId opt_storage_drop_specifier */ + case 251: #line 8 "third_party/libpg_query/grammar/statements/drop_secret.y" - { + { PGDropSecretStmt *n = makeNode(PGDropSecretStmt); - n->persist_type = (yyvsp[-3].str); - n->secret_name = (yyvsp[-1].str); - n->secret_storage = (yyvsp[0].str); + n->persist_type = (yyvsp[(2) - (5)].str); + n->secret_name = (yyvsp[(4) - (5)].str); + n->secret_storage = (yyvsp[(5) - (5)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 20886 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 252: /* DropSecretStmt: DROP opt_persist SECRET IF_P EXISTS ColId opt_storage_drop_specifier */ + case 252: #line 17 "third_party/libpg_query/grammar/statements/drop_secret.y" - { + { PGDropSecretStmt *n = makeNode(PGDropSecretStmt); - n->persist_type = (yyvsp[-5].str); - n->secret_name = (yyvsp[-1].str); - n->secret_storage = (yyvsp[0].str); + n->persist_type = (yyvsp[(2) - (7)].str); + n->secret_name = (yyvsp[(6) - (7)].str); + n->secret_storage = (yyvsp[(7) - (7)].str); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 20899 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 253: /* opt_storage_drop_specifier: %empty */ + case 253: #line 28 "third_party/libpg_query/grammar/statements/drop_secret.y" - { (yyval.str) = pstrdup(""); } -#line 20905 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup(""); ;} break; - case 254: /* opt_storage_drop_specifier: FROM IDENT */ + case 254: #line 29 "third_party/libpg_query/grammar/statements/drop_secret.y" - { (yyval.str) = (yyvsp[0].str); } -#line 20911 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 255: /* TransactionStmt: ABORT_P opt_transaction */ + case 255: #line 3 "third_party/libpg_query/grammar/statements/transaction.y" - { + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_ROLLBACK; n->options = NIL; (yyval.node) = (PGNode *)n; - } -#line 20922 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 256: /* TransactionStmt: BEGIN_P opt_transaction */ + case 256: #line 10 "third_party/libpg_query/grammar/statements/transaction.y" - { + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_BEGIN; (yyval.node) = (PGNode *)n; - } -#line 20932 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 257: /* TransactionStmt: START opt_transaction */ + case 257: #line 16 "third_party/libpg_query/grammar/statements/transaction.y" - { + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_START; (yyval.node) = (PGNode *)n; - } -#line 20942 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 258: /* TransactionStmt: COMMIT opt_transaction */ + case 258: #line 22 "third_party/libpg_query/grammar/statements/transaction.y" - { + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_COMMIT; n->options = NIL; (yyval.node) = (PGNode *)n; - } -#line 20953 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 259: /* TransactionStmt: END_P opt_transaction */ + case 259: #line 29 "third_party/libpg_query/grammar/statements/transaction.y" - { + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_COMMIT; n->options = NIL; (yyval.node) = (PGNode *)n; - } -#line 20964 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 260: /* TransactionStmt: ROLLBACK opt_transaction */ + case 260: #line 36 "third_party/libpg_query/grammar/statements/transaction.y" - { + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_ROLLBACK; n->options = NIL; (yyval.node) = (PGNode *)n; - } -#line 20975 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 261: /* opt_transaction: WORK */ + case 261: #line 45 "third_party/libpg_query/grammar/statements/transaction.y" - {} -#line 20981 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 262: /* opt_transaction: TRANSACTION */ + case 262: #line 46 "third_party/libpg_query/grammar/statements/transaction.y" - {} -#line 20987 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 263: /* opt_transaction: %empty */ + case 263: #line 47 "third_party/libpg_query/grammar/statements/transaction.y" - {} -#line 20993 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 264: /* UseStmt: USE_P qualified_name */ + case 264: #line 3 "third_party/libpg_query/grammar/statements/use.y" - { + { PGUseStmt *n = makeNode(PGUseStmt); - n->name = (yyvsp[0].range); + n->name = (yyvsp[(2) - (2)].range); (yyval.node) = (PGNode *) n; - } -#line 21003 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 265: /* CreateStmt: CREATE_P OptTemp TABLE qualified_name '(' OptTableElementList ')' OptWith OnCommitOption */ + case 265: #line 9 "third_party/libpg_query/grammar/statements/create.y" - { + { PGCreateStmt *n = makeNode(PGCreateStmt); - (yyvsp[-5].range)->relpersistence = (yyvsp[-7].ival); - n->relation = (yyvsp[-5].range); - n->tableElts = (yyvsp[-3].list); + (yyvsp[(4) - (9)].range)->relpersistence = (yyvsp[(2) - (9)].ival); + n->relation = (yyvsp[(4) - (9)].range); + n->tableElts = (yyvsp[(6) - (9)].list); n->ofTypename = NULL; n->constraints = NIL; - n->options = (yyvsp[-1].list); - n->oncommit = (yyvsp[0].oncommit); + n->options = (yyvsp[(8) - (9)].list); + n->oncommit = (yyvsp[(9) - (9)].oncommit); n->onconflict = PG_ERROR_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 21020 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 266: /* CreateStmt: CREATE_P OptTemp TABLE IF_P NOT EXISTS qualified_name '(' OptTableElementList ')' OptWith OnCommitOption */ + case 266: #line 24 "third_party/libpg_query/grammar/statements/create.y" - { + { PGCreateStmt *n = makeNode(PGCreateStmt); - (yyvsp[-5].range)->relpersistence = (yyvsp[-10].ival); - n->relation = (yyvsp[-5].range); - n->tableElts = (yyvsp[-3].list); + (yyvsp[(7) - (12)].range)->relpersistence = (yyvsp[(2) - (12)].ival); + n->relation = (yyvsp[(7) - (12)].range); + n->tableElts = (yyvsp[(9) - (12)].list); n->ofTypename = NULL; n->constraints = NIL; - n->options = (yyvsp[-1].list); - n->oncommit = (yyvsp[0].oncommit); + n->options = (yyvsp[(11) - (12)].list); + n->oncommit = (yyvsp[(12) - (12)].oncommit); n->onconflict = PG_IGNORE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 21037 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 267: /* CreateStmt: CREATE_P OR REPLACE OptTemp TABLE qualified_name '(' OptTableElementList ')' OptWith OnCommitOption */ + case 267: #line 39 "third_party/libpg_query/grammar/statements/create.y" - { + { PGCreateStmt *n = makeNode(PGCreateStmt); - (yyvsp[-5].range)->relpersistence = (yyvsp[-7].ival); - n->relation = (yyvsp[-5].range); - n->tableElts = (yyvsp[-3].list); + (yyvsp[(6) - (11)].range)->relpersistence = (yyvsp[(4) - (11)].ival); + n->relation = (yyvsp[(6) - (11)].range); + n->tableElts = (yyvsp[(8) - (11)].list); n->ofTypename = NULL; n->constraints = NIL; - n->options = (yyvsp[-1].list); - n->oncommit = (yyvsp[0].oncommit); + n->options = (yyvsp[(10) - (11)].list); + n->oncommit = (yyvsp[(11) - (11)].oncommit); n->onconflict = PG_REPLACE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 21054 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 268: /* ConstraintAttributeSpec: %empty */ + case 268: #line 56 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = 0; } -#line 21060 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 269: /* ConstraintAttributeSpec: ConstraintAttributeSpec ConstraintAttributeElem */ + case 269: #line 58 "third_party/libpg_query/grammar/statements/create.y" - { + { /* * We must complain about conflicting options. * We could, but choose not to, complain about redundant * options (ie, where $2's bit is already set in $1). */ - int newspec = (yyvsp[-1].ival) | (yyvsp[0].ival); + int newspec = (yyvsp[(1) - (2)].ival) | (yyvsp[(2) - (2)].ival); /* special message for this case */ if ((newspec & (CAS_NOT_DEFERRABLE | CAS_INITIALLY_DEFERRED)) == (CAS_NOT_DEFERRABLE | CAS_INITIALLY_DEFERRED)) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("constraint declared INITIALLY DEFERRED must be DEFERRABLE"), - parser_errposition((yylsp[0])))); + parser_errposition((yylsp[(2) - (2)])))); /* generic message for other conflicts */ if ((newspec & (CAS_NOT_DEFERRABLE | CAS_DEFERRABLE)) == (CAS_NOT_DEFERRABLE | CAS_DEFERRABLE) || (newspec & (CAS_INITIALLY_IMMEDIATE | CAS_INITIALLY_DEFERRED)) == (CAS_INITIALLY_IMMEDIATE | CAS_INITIALLY_DEFERRED)) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("conflicting constraint properties"), - parser_errposition((yylsp[0])))); + parser_errposition((yylsp[(2) - (2)])))); (yyval.ival) = newspec; - } -#line 21088 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 270: /* def_arg: func_type */ + case 270: #line 84 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)(yyvsp[0].typnam); } -#line 21094 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].typnam); ;} break; - case 271: /* def_arg: reserved_keyword */ + case 271: #line 85 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[0].keyword))); } -#line 21100 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[(1) - (1)].keyword))); ;} break; - case 272: /* def_arg: qual_all_Op */ + case 272: #line 86 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)(yyvsp[0].list); } -#line 21106 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].list); ;} break; - case 273: /* def_arg: NumericOnly */ + case 273: #line 87 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)(yyvsp[0].value); } -#line 21112 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].value); ;} break; - case 274: /* def_arg: Sconst */ + case 274: #line 88 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)makeString((yyvsp[0].str)); } -#line 21118 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)makeString((yyvsp[(1) - (1)].str)); ;} break; - case 275: /* def_arg: NONE */ + case 275: #line 89 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[0].keyword))); } -#line 21124 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[(1) - (1)].keyword))); ;} break; - case 276: /* OptParenthesizedSeqOptList: '(' SeqOptList ')' */ + case 276: #line 93 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 21130 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 277: /* OptParenthesizedSeqOptList: %empty */ + case 277: #line 94 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 21136 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 278: /* generic_option_arg: Sconst */ + case 278: #line 99 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); } -#line 21142 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;} break; - case 279: /* key_action: NO ACTION */ + case 279: #line 104 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_FKCONSTR_ACTION_NOACTION; } -#line 21148 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_FKCONSTR_ACTION_NOACTION; ;} break; - case 280: /* key_action: RESTRICT */ + case 280: #line 105 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_FKCONSTR_ACTION_RESTRICT; } -#line 21154 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_FKCONSTR_ACTION_RESTRICT; ;} break; - case 281: /* key_action: CASCADE */ + case 281: #line 106 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_FKCONSTR_ACTION_CASCADE; } -#line 21160 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_FKCONSTR_ACTION_CASCADE; ;} break; - case 282: /* key_action: SET NULL_P */ + case 282: #line 107 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_FKCONSTR_ACTION_SETNULL; } -#line 21166 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_FKCONSTR_ACTION_SETNULL; ;} break; - case 283: /* key_action: SET DEFAULT */ + case 283: #line 108 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_FKCONSTR_ACTION_SETDEFAULT; } -#line 21172 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_FKCONSTR_ACTION_SETDEFAULT; ;} break; - case 284: /* ColConstraint: CONSTRAINT name ColConstraintElem */ + case 284: #line 114 "third_party/libpg_query/grammar/statements/create.y" - { - PGConstraint *n = castNode(PGConstraint, (yyvsp[0].node)); - n->conname = (yyvsp[-1].str); - n->location = (yylsp[-2]); + { + PGConstraint *n = castNode(PGConstraint, (yyvsp[(3) - (3)].node)); + n->conname = (yyvsp[(2) - (3)].str); + n->location = (yylsp[(1) - (3)]); (yyval.node) = (PGNode *) n; - } -#line 21183 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 285: /* ColConstraint: ColConstraintElem */ + case 285: #line 120 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 21189 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 286: /* ColConstraint: ConstraintAttr */ + case 286: #line 121 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 21195 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 287: /* ColConstraint: COLLATE any_name */ + case 287: #line 123 "third_party/libpg_query/grammar/statements/create.y" - { + { /* * Note: the PGCollateClause is momentarily included in * the list built by ColQualList, but we split it out @@ -407720,169 +412033,155 @@ YYLTYPE yylloc = yyloc_default; */ PGCollateClause *n = makeNode(PGCollateClause); n->arg = NULL; - n->collname = (yyvsp[0].list); - n->location = (yylsp[-1]); + n->collname = (yyvsp[(2) - (2)].list); + n->location = (yylsp[(1) - (2)]); (yyval.node) = (PGNode *) n; - } -#line 21212 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 288: /* ColConstraintElem: NOT NULL_P */ + case 288: #line 140 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_NOTNULL; - n->location = (yylsp[-1]); + n->location = (yylsp[(1) - (2)]); (yyval.node) = (PGNode *)n; - } -#line 21223 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 289: /* ColConstraintElem: NULL_P */ + case 289: #line 147 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_NULL; - n->location = (yylsp[0]); + n->location = (yylsp[(1) - (1)]); (yyval.node) = (PGNode *)n; - } -#line 21234 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 290: /* ColConstraintElem: UNIQUE opt_definition */ + case 290: #line 154 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_UNIQUE; - n->location = (yylsp[-1]); + n->location = (yylsp[(1) - (2)]); n->keys = NULL; - n->options = (yyvsp[0].list); + n->options = (yyvsp[(2) - (2)].list); n->indexname = NULL; (yyval.node) = (PGNode *)n; - } -#line 21248 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 291: /* ColConstraintElem: PRIMARY KEY opt_definition */ + case 291: #line 164 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_PRIMARY; - n->location = (yylsp[-2]); + n->location = (yylsp[(1) - (3)]); n->keys = NULL; - n->options = (yyvsp[0].list); + n->options = (yyvsp[(3) - (3)].list); n->indexname = NULL; (yyval.node) = (PGNode *)n; - } -#line 21262 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 292: /* ColConstraintElem: CHECK_P '(' a_expr ')' opt_no_inherit */ + case 292: #line 174 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_CHECK; - n->location = (yylsp[-4]); - n->is_no_inherit = (yyvsp[0].boolean); - n->raw_expr = (yyvsp[-2].node); + n->location = (yylsp[(1) - (5)]); + n->is_no_inherit = (yyvsp[(5) - (5)].boolean); + n->raw_expr = (yyvsp[(3) - (5)].node); n->cooked_expr = NULL; n->skip_validation = false; n->initially_valid = true; (yyval.node) = (PGNode *)n; - } -#line 21278 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 293: /* ColConstraintElem: USING COMPRESSION name */ + case 293: #line 186 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_COMPRESSION; - n->location = (yylsp[-2]); - n->compression_name = (yyvsp[0].str); + n->location = (yylsp[(1) - (3)]); + n->compression_name = (yyvsp[(3) - (3)].str); (yyval.node) = (PGNode *)n; - } -#line 21290 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 294: /* ColConstraintElem: DEFAULT b_expr */ + case 294: #line 194 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_DEFAULT; - n->location = (yylsp[-1]); - n->raw_expr = (yyvsp[0].node); + n->location = (yylsp[(1) - (2)]); + n->raw_expr = (yyvsp[(2) - (2)].node); n->cooked_expr = NULL; (yyval.node) = (PGNode *)n; - } -#line 21303 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 295: /* ColConstraintElem: REFERENCES qualified_name opt_column_list key_match key_actions */ + case 295: #line 203 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_FOREIGN; - n->location = (yylsp[-4]); - n->pktable = (yyvsp[-3].range); + n->location = (yylsp[(1) - (5)]); + n->pktable = (yyvsp[(2) - (5)].range); n->fk_attrs = NIL; - n->pk_attrs = (yyvsp[-2].list); - n->fk_matchtype = (yyvsp[-1].ival); - n->fk_upd_action = (char) ((yyvsp[0].ival) >> 8); - n->fk_del_action = (char) ((yyvsp[0].ival) & 0xFF); + n->pk_attrs = (yyvsp[(3) - (5)].list); + n->fk_matchtype = (yyvsp[(4) - (5)].ival); + n->fk_upd_action = (char) ((yyvsp[(5) - (5)].ival) >> 8); + n->fk_del_action = (char) ((yyvsp[(5) - (5)].ival) & 0xFF); n->skip_validation = false; n->initially_valid = true; (yyval.node) = (PGNode *)n; - } -#line 21322 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 296: /* GeneratedColumnType: VIRTUAL */ + case 296: #line 220 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; } -#line 21328 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; ;} break; - case 297: /* GeneratedColumnType: STORED */ + case 297: #line 221 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.constr) = PG_CONSTR_GENERATED_STORED; } -#line 21334 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.constr) = PG_CONSTR_GENERATED_STORED; ;} break; - case 298: /* opt_GeneratedColumnType: GeneratedColumnType */ + case 298: #line 225 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.constr) = (yyvsp[0].constr); } -#line 21340 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.constr) = (yyvsp[(1) - (1)].constr); ;} break; - case 299: /* opt_GeneratedColumnType: %empty */ + case 299: #line 226 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; } -#line 21346 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; ;} break; - case 300: /* GeneratedConstraintElem: GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList */ + case 300: #line 231 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_IDENTITY; - n->generated_when = (yyvsp[-3].ival); - n->options = (yyvsp[0].list); - n->location = (yylsp[-4]); + n->generated_when = (yyvsp[(2) - (5)].ival); + n->options = (yyvsp[(5) - (5)].list); + n->location = (yylsp[(1) - (5)]); (yyval.node) = (PGNode *)n; - } -#line 21359 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 301: /* GeneratedConstraintElem: GENERATED generated_when AS '(' a_expr ')' opt_GeneratedColumnType */ + case 301: #line 240 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); - n->contype = (yyvsp[0].constr); - n->generated_when = (yyvsp[-5].ival); - n->raw_expr = (yyvsp[-2].node); + n->contype = (yyvsp[(7) - (7)].constr); + n->generated_when = (yyvsp[(2) - (7)].ival); + n->raw_expr = (yyvsp[(5) - (7)].node); n->cooked_expr = NULL; - n->location = (yylsp[-6]); + n->location = (yylsp[(1) - (7)]); /* * Can't do this in the grammar because of shift/reduce @@ -407890,341 +412189,293 @@ YYLTYPE yylloc = yyloc_default; * DEFAULT, but generated columns only allow ALWAYS.) We * can also give a more useful error message and location. */ - if ((yyvsp[-5].ival) != PG_ATTRIBUTE_IDENTITY_ALWAYS) + if ((yyvsp[(2) - (7)].ival) != PG_ATTRIBUTE_IDENTITY_ALWAYS) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("for a generated column, GENERATED ALWAYS must be specified"), - parser_errposition((yylsp[-5])))); + parser_errposition((yylsp[(2) - (7)])))); (yyval.node) = (PGNode *)n; - } -#line 21386 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 302: /* GeneratedConstraintElem: AS '(' a_expr ')' opt_GeneratedColumnType */ + case 302: #line 263 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); - n->contype = (yyvsp[0].constr); + n->contype = (yyvsp[(5) - (5)].constr); n->generated_when = PG_ATTRIBUTE_IDENTITY_ALWAYS; - n->raw_expr = (yyvsp[-2].node); + n->raw_expr = (yyvsp[(3) - (5)].node); n->cooked_expr = NULL; - n->location = (yylsp[-4]); + n->location = (yylsp[(1) - (5)]); (yyval.node) = (PGNode *)n; - } -#line 21400 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 303: /* generic_option_elem: generic_option_name generic_option_arg */ + case 303: #line 277 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElem((yyvsp[-1].str), (yyvsp[0].node), (yylsp[-1])); - } -#line 21408 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); + ;} break; - case 304: /* key_update: ON UPDATE key_action */ + case 304: #line 283 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (yyvsp[0].ival); } -#line 21414 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;} break; - case 305: /* key_actions: key_update */ + case 305: #line 289 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = ((yyvsp[0].ival) << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); } -#line 21420 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = ((yyvsp[(1) - (1)].ival) << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); ;} break; - case 306: /* key_actions: key_delete */ + case 306: #line 291 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | ((yyvsp[0].ival) & 0xFF); } -#line 21426 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | ((yyvsp[(1) - (1)].ival) & 0xFF); ;} break; - case 307: /* key_actions: key_update key_delete */ + case 307: #line 293 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = ((yyvsp[-1].ival) << 8) | ((yyvsp[0].ival) & 0xFF); } -#line 21432 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = ((yyvsp[(1) - (2)].ival) << 8) | ((yyvsp[(2) - (2)].ival) & 0xFF); ;} break; - case 308: /* key_actions: key_delete key_update */ + case 308: #line 295 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = ((yyvsp[0].ival) << 8) | ((yyvsp[-1].ival) & 0xFF); } -#line 21438 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = ((yyvsp[(2) - (2)].ival) << 8) | ((yyvsp[(1) - (2)].ival) & 0xFF); ;} break; - case 309: /* key_actions: %empty */ + case 309: #line 297 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); } -#line 21444 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); ;} break; - case 310: /* OnCommitOption: ON COMMIT DROP */ + case 310: #line 300 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.oncommit) = ONCOMMIT_DROP; } -#line 21450 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.oncommit) = ONCOMMIT_DROP; ;} break; - case 311: /* OnCommitOption: ON COMMIT DELETE_P ROWS */ + case 311: #line 301 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.oncommit) = PG_ONCOMMIT_DELETE_ROWS; } -#line 21456 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.oncommit) = PG_ONCOMMIT_DELETE_ROWS; ;} break; - case 312: /* OnCommitOption: ON COMMIT PRESERVE ROWS */ + case 312: #line 302 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.oncommit) = PG_ONCOMMIT_PRESERVE_ROWS; } -#line 21462 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.oncommit) = PG_ONCOMMIT_PRESERVE_ROWS; ;} break; - case 313: /* OnCommitOption: %empty */ + case 313: #line 303 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.oncommit) = PG_ONCOMMIT_NOOP; } -#line 21468 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.oncommit) = PG_ONCOMMIT_NOOP; ;} break; - case 314: /* reloptions: '(' reloption_list ')' */ + case 314: #line 308 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 21474 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 315: /* opt_no_inherit: NO INHERIT */ + case 315: #line 312 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.boolean) = true; } -#line 21480 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 316: /* opt_no_inherit: %empty */ + case 316: #line 313 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.boolean) = false; } -#line 21486 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 317: /* TableConstraint: CONSTRAINT name ConstraintElem */ + case 317: #line 319 "third_party/libpg_query/grammar/statements/create.y" - { - PGConstraint *n = castNode(PGConstraint, (yyvsp[0].node)); - n->conname = (yyvsp[-1].str); - n->location = (yylsp[-2]); + { + PGConstraint *n = castNode(PGConstraint, (yyvsp[(3) - (3)].node)); + n->conname = (yyvsp[(2) - (3)].str); + n->location = (yylsp[(1) - (3)]); (yyval.node) = (PGNode *) n; - } -#line 21497 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 318: /* TableConstraint: ConstraintElem */ + case 318: #line 325 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 21503 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 319: /* TableLikeOption: COMMENTS */ + case 319: #line 330 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_COMMENTS; } -#line 21509 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_COMMENTS; ;} break; - case 320: /* TableLikeOption: CONSTRAINTS */ + case 320: #line 331 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_CONSTRAINTS; } -#line 21515 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_CONSTRAINTS; ;} break; - case 321: /* TableLikeOption: DEFAULTS */ + case 321: #line 332 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_DEFAULTS; } -#line 21521 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_DEFAULTS; ;} break; - case 322: /* TableLikeOption: IDENTITY_P */ + case 322: #line 333 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_IDENTITY; } -#line 21527 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_IDENTITY; ;} break; - case 323: /* TableLikeOption: INDEXES */ + case 323: #line 334 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_INDEXES; } -#line 21533 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_INDEXES; ;} break; - case 324: /* TableLikeOption: STATISTICS */ + case 324: #line 335 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_STATISTICS; } -#line 21539 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_STATISTICS; ;} break; - case 325: /* TableLikeOption: STORAGE */ + case 325: #line 336 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_STORAGE; } -#line 21545 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_STORAGE; ;} break; - case 326: /* TableLikeOption: ALL */ + case 326: #line 337 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_ALL; } -#line 21551 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_ALL; ;} break; - case 327: /* reloption_list: reloption_elem */ + case 327: #line 343 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1((yyvsp[0].defelt)); } -#line 21557 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; - case 328: /* reloption_list: reloption_list ',' reloption_elem */ + case 328: #line 344 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt)); } -#line 21563 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} break; - case 329: /* ExistingIndex: USING INDEX index_name */ + case 329: #line 348 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.str) = (yyvsp[0].str); } -#line 21569 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(3) - (3)].str); ;} break; - case 330: /* ConstraintAttr: DEFERRABLE */ + case 330: #line 354 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_ATTR_DEFERRABLE; - n->location = (yylsp[0]); + n->location = (yylsp[(1) - (1)]); (yyval.node) = (PGNode *)n; - } -#line 21580 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 331: /* ConstraintAttr: NOT DEFERRABLE */ + case 331: #line 361 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_ATTR_NOT_DEFERRABLE; - n->location = (yylsp[-1]); + n->location = (yylsp[(1) - (2)]); (yyval.node) = (PGNode *)n; - } -#line 21591 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 332: /* ConstraintAttr: INITIALLY DEFERRED */ + case 332: #line 368 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_ATTR_DEFERRED; - n->location = (yylsp[-1]); + n->location = (yylsp[(1) - (2)]); (yyval.node) = (PGNode *)n; - } -#line 21602 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 333: /* ConstraintAttr: INITIALLY IMMEDIATE */ + case 333: #line 375 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_ATTR_IMMEDIATE; - n->location = (yylsp[-1]); + n->location = (yylsp[(1) - (2)]); (yyval.node) = (PGNode *)n; - } -#line 21613 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 334: /* OptWith: WITH reloptions */ + case 334: #line 386 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[0].list); } -#line 21619 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 335: /* OptWith: WITH OIDS */ + case 335: #line 387 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(true), (yylsp[-1]))); } -#line 21625 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(true), (yylsp[(1) - (2)]))); ;} break; - case 336: /* OptWith: WITHOUT OIDS */ + case 336: #line 388 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(false), (yylsp[-1]))); } -#line 21631 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(false), (yylsp[(1) - (2)]))); ;} break; - case 337: /* OptWith: %empty */ + case 337: #line 389 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 21637 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 338: /* definition: '(' def_list ')' */ + case 338: #line 393 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 21643 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 339: /* TableLikeOptionList: TableLikeOptionList INCLUDING TableLikeOption */ + case 339: #line 398 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (yyvsp[-2].ival) | (yyvsp[0].ival); } -#line 21649 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;} break; - case 340: /* TableLikeOptionList: TableLikeOptionList EXCLUDING TableLikeOption */ + case 340: #line 399 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (yyvsp[-2].ival) & ~(yyvsp[0].ival); } -#line 21655 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(1) - (3)].ival) & ~(yyvsp[(3) - (3)].ival); ;} break; - case 341: /* TableLikeOptionList: %empty */ + case 341: #line 400 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = 0; } -#line 21661 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 342: /* generic_option_name: ColLabel */ + case 342: #line 405 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.str) = (yyvsp[0].str); } -#line 21667 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 343: /* ConstraintAttributeElem: NOT DEFERRABLE */ + case 343: #line 410 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_NOT_DEFERRABLE; } -#line 21673 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_NOT_DEFERRABLE; ;} break; - case 344: /* ConstraintAttributeElem: DEFERRABLE */ + case 344: #line 411 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_DEFERRABLE; } -#line 21679 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_DEFERRABLE; ;} break; - case 345: /* ConstraintAttributeElem: INITIALLY IMMEDIATE */ + case 345: #line 412 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_INITIALLY_IMMEDIATE; } -#line 21685 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_INITIALLY_IMMEDIATE; ;} break; - case 346: /* ConstraintAttributeElem: INITIALLY DEFERRED */ + case 346: #line 413 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_INITIALLY_DEFERRED; } -#line 21691 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_INITIALLY_DEFERRED; ;} break; - case 347: /* ConstraintAttributeElem: NOT VALID */ + case 347: #line 414 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_NOT_VALID; } -#line 21697 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_NOT_VALID; ;} break; - case 348: /* ConstraintAttributeElem: NO INHERIT */ + case 348: #line 415 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_NO_INHERIT; } -#line 21703 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_NO_INHERIT; ;} break; - case 349: /* columnDef: ColId Typename ColQualList */ + case 349: #line 421 "third_party/libpg_query/grammar/statements/create.y" - { + { PGColumnDef *n = makeNode(PGColumnDef); n->category = COL_STANDARD; - n->colname = (yyvsp[-2].str); - n->typeName = (yyvsp[-1].typnam); + n->colname = (yyvsp[(1) - (3)].str); + n->typeName = (yyvsp[(2) - (3)].typnam); n->inhcount = 0; n->is_local = true; n->is_not_null = false; @@ -408233,21 +412484,20 @@ YYLTYPE yylloc = yyloc_default; n->raw_default = NULL; n->cooked_default = NULL; n->collOid = InvalidOid; - SplitColQualList((yyvsp[0].list), &n->constraints, &n->collClause, + SplitColQualList((yyvsp[(3) - (3)].list), &n->constraints, &n->collClause, yyscanner); - n->location = (yylsp[-2]); + n->location = (yylsp[(1) - (3)]); (yyval.node) = (PGNode *)n; - } -#line 21726 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 350: /* columnDef: ColId opt_Typename GeneratedConstraintElem ColQualList */ + case 350: #line 441 "third_party/libpg_query/grammar/statements/create.y" - { + { PGColumnDef *n = makeNode(PGColumnDef); n->category = COL_GENERATED; - n->colname = (yyvsp[-3].str); - n->typeName = (yyvsp[-2].typnam); + n->colname = (yyvsp[(1) - (4)].str); + n->typeName = (yyvsp[(2) - (4)].typnam); n->inhcount = 0; n->is_local = true; n->is_not_null = false; @@ -408257,1525 +412507,1347 @@ YYLTYPE yylloc = yyloc_default; n->cooked_default = NULL; n->collOid = InvalidOid; // merge the constraints with the generated column constraint - auto constraints = (yyvsp[0].list); + auto constraints = (yyvsp[(4) - (4)].list); if (constraints) { - constraints = lappend(constraints, (yyvsp[-1].node)); + constraints = lappend(constraints, (yyvsp[(3) - (4)].node)); } else { - constraints = list_make1((yyvsp[-1].node)); + constraints = list_make1((yyvsp[(3) - (4)].node)); } SplitColQualList(constraints, &n->constraints, &n->collClause, yyscanner); - n->location = (yylsp[-3]); + n->location = (yylsp[(1) - (4)]); (yyval.node) = (PGNode *)n; - } -#line 21756 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 351: /* def_list: def_elem */ + case 351: #line 469 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1((yyvsp[0].defelt)); } -#line 21762 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; - case 352: /* def_list: def_list ',' def_elem */ + case 352: #line 470 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt)); } -#line 21768 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} break; - case 353: /* index_name: ColId */ + case 353: #line 474 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.str) = (yyvsp[0].str); } -#line 21774 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 354: /* TableElement: columnDef */ + case 354: #line 478 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 21780 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 355: /* TableElement: TableLikeClause */ + case 355: #line 479 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 21786 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 356: /* TableElement: TableConstraint */ + case 356: #line 480 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 21792 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 357: /* def_elem: ColLabel '=' def_arg */ + case 357: #line 485 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElem((yyvsp[-2].str), (PGNode *) (yyvsp[0].node), (yylsp[-2])); - } -#line 21800 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (PGNode *) (yyvsp[(3) - (3)].node), (yylsp[(1) - (3)])); + ;} break; - case 358: /* def_elem: ColLabel */ + case 358: #line 489 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElem((yyvsp[0].str), NULL, (yylsp[0])); - } -#line 21808 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL, (yylsp[(1) - (1)])); + ;} break; - case 359: /* opt_definition: WITH definition */ + case 359: #line 496 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[0].list); } -#line 21814 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 360: /* opt_definition: %empty */ + case 360: #line 497 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 21820 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 361: /* OptTableElementList: TableElementList */ + case 361: #line 502 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[0].list); } -#line 21826 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 362: /* OptTableElementList: TableElementList ',' */ + case 362: #line 503 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 21832 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 363: /* OptTableElementList: %empty */ + case 363: #line 504 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 21838 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 364: /* columnElem: ColId */ + case 364: #line 509 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); - } -#line 21846 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); + ;} break; - case 365: /* opt_column_list: '(' columnList ')' */ + case 365: #line 516 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 21852 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 366: /* opt_column_list: %empty */ + case 366: #line 517 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 21858 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 367: /* ColQualList: ColQualList ColConstraint */ + case 367: #line 522 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 21864 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 368: /* ColQualList: %empty */ + case 368: #line 523 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 21870 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 369: /* key_delete: ON DELETE_P key_action */ + case 369: #line 527 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (yyvsp[0].ival); } -#line 21876 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;} break; - case 370: /* reloption_elem: ColLabel '=' def_arg */ + case 370: #line 533 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElem((yyvsp[-2].str), (PGNode *) (yyvsp[0].node), (yylsp[-2])); - } -#line 21884 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (PGNode *) (yyvsp[(3) - (3)].node), (yylsp[(1) - (3)])); + ;} break; - case 371: /* reloption_elem: ColLabel */ + case 371: #line 537 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElem((yyvsp[0].str), NULL, (yylsp[0])); - } -#line 21892 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL, (yylsp[(1) - (1)])); + ;} break; - case 372: /* reloption_elem: ColLabel '.' ColLabel '=' def_arg */ + case 372: #line 541 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElemExtended((yyvsp[-4].str), (yyvsp[-2].str), (PGNode *) (yyvsp[0].node), - PG_DEFELEM_UNSPEC, (yylsp[-4])); - } -#line 21901 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElemExtended((yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (PGNode *) (yyvsp[(5) - (5)].node), + PG_DEFELEM_UNSPEC, (yylsp[(1) - (5)])); + ;} break; - case 373: /* reloption_elem: ColLabel '.' ColLabel */ + case 373: #line 546 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElemExtended((yyvsp[-2].str), (yyvsp[0].str), NULL, PG_DEFELEM_UNSPEC, (yylsp[-2])); - } -#line 21909 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElemExtended((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str), NULL, PG_DEFELEM_UNSPEC, (yylsp[(1) - (3)])); + ;} break; - case 374: /* columnList: columnElem */ + case 374: #line 553 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 21915 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 375: /* columnList: columnList ',' columnElem */ + case 375: #line 554 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 21921 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 376: /* columnList_opt_comma: columnList */ + case 376: #line 558 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[0].list); } -#line 21927 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 377: /* columnList_opt_comma: columnList ',' */ + case 377: #line 559 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 21933 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 378: /* func_type: Typename */ + case 378: #line 563 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 21939 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 379: /* func_type: type_function_name attrs '%' TYPE_P */ + case 379: #line 565 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[-3].str)), (yyvsp[-2].list))); + { + (yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[(1) - (4)].str)), (yyvsp[(2) - (4)].list))); (yyval.typnam)->pct_type = true; - (yyval.typnam)->location = (yylsp[-3]); - } -#line 21949 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (4)]); + ;} break; - case 380: /* func_type: SETOF type_function_name attrs '%' TYPE_P */ + case 380: #line 571 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[-3].str)), (yyvsp[-2].list))); + { + (yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[(2) - (5)].str)), (yyvsp[(3) - (5)].list))); (yyval.typnam)->pct_type = true; (yyval.typnam)->setof = true; - (yyval.typnam)->location = (yylsp[-3]); - } -#line 21960 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(2) - (5)]); + ;} break; - case 381: /* ConstraintElem: CHECK_P '(' a_expr ')' ConstraintAttributeSpec */ + case 381: #line 582 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_CHECK; - n->location = (yylsp[-4]); - n->raw_expr = (yyvsp[-2].node); + n->location = (yylsp[(1) - (5)]); + n->raw_expr = (yyvsp[(3) - (5)].node); n->cooked_expr = NULL; - processCASbits((yyvsp[0].ival), (yylsp[0]), "CHECK", + processCASbits((yyvsp[(5) - (5)].ival), (yylsp[(5) - (5)]), "CHECK", NULL, NULL, &n->skip_validation, &n->is_no_inherit, yyscanner); n->initially_valid = !n->skip_validation; (yyval.node) = (PGNode *)n; - } -#line 21977 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 382: /* ConstraintElem: UNIQUE '(' columnList_opt_comma ')' opt_definition ConstraintAttributeSpec */ + case 382: #line 596 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_UNIQUE; - n->location = (yylsp[-5]); - n->keys = (yyvsp[-3].list); - n->options = (yyvsp[-1].list); + n->location = (yylsp[(1) - (6)]); + n->keys = (yyvsp[(3) - (6)].list); + n->options = (yyvsp[(5) - (6)].list); n->indexname = NULL; - processCASbits((yyvsp[0].ival), (yylsp[0]), "UNIQUE", + processCASbits((yyvsp[(6) - (6)].ival), (yylsp[(6) - (6)]), "UNIQUE", &n->deferrable, &n->initdeferred, NULL, NULL, yyscanner); (yyval.node) = (PGNode *)n; - } -#line 21994 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 383: /* ConstraintElem: UNIQUE ExistingIndex ConstraintAttributeSpec */ + case 383: #line 609 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_UNIQUE; - n->location = (yylsp[-2]); + n->location = (yylsp[(1) - (3)]); n->keys = NIL; n->options = NIL; - n->indexname = (yyvsp[-1].str); + n->indexname = (yyvsp[(2) - (3)].str); n->indexspace = NULL; - processCASbits((yyvsp[0].ival), (yylsp[0]), "UNIQUE", + processCASbits((yyvsp[(3) - (3)].ival), (yylsp[(3) - (3)]), "UNIQUE", &n->deferrable, &n->initdeferred, NULL, NULL, yyscanner); (yyval.node) = (PGNode *)n; - } -#line 22012 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 384: /* ConstraintElem: PRIMARY KEY '(' columnList_opt_comma ')' opt_definition ConstraintAttributeSpec */ + case 384: #line 624 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_PRIMARY; - n->location = (yylsp[-6]); - n->keys = (yyvsp[-3].list); - n->options = (yyvsp[-1].list); + n->location = (yylsp[(1) - (7)]); + n->keys = (yyvsp[(4) - (7)].list); + n->options = (yyvsp[(6) - (7)].list); n->indexname = NULL; - processCASbits((yyvsp[0].ival), (yylsp[0]), "PRIMARY KEY", + processCASbits((yyvsp[(7) - (7)].ival), (yylsp[(7) - (7)]), "PRIMARY KEY", &n->deferrable, &n->initdeferred, NULL, NULL, yyscanner); (yyval.node) = (PGNode *)n; - } -#line 22029 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 385: /* ConstraintElem: PRIMARY KEY ExistingIndex ConstraintAttributeSpec */ + case 385: #line 637 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_PRIMARY; - n->location = (yylsp[-3]); + n->location = (yylsp[(1) - (4)]); n->keys = NIL; n->options = NIL; - n->indexname = (yyvsp[-1].str); + n->indexname = (yyvsp[(3) - (4)].str); n->indexspace = NULL; - processCASbits((yyvsp[0].ival), (yylsp[0]), "PRIMARY KEY", + processCASbits((yyvsp[(4) - (4)].ival), (yylsp[(4) - (4)]), "PRIMARY KEY", &n->deferrable, &n->initdeferred, NULL, NULL, yyscanner); (yyval.node) = (PGNode *)n; - } -#line 22047 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 386: /* ConstraintElem: FOREIGN KEY '(' columnList_opt_comma ')' REFERENCES qualified_name opt_column_list key_match key_actions ConstraintAttributeSpec */ + case 386: #line 652 "third_party/libpg_query/grammar/statements/create.y" - { + { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_FOREIGN; - n->location = (yylsp[-10]); - n->pktable = (yyvsp[-4].range); - n->fk_attrs = (yyvsp[-7].list); - n->pk_attrs = (yyvsp[-3].list); - n->fk_matchtype = (yyvsp[-2].ival); - n->fk_upd_action = (char) ((yyvsp[-1].ival) >> 8); - n->fk_del_action = (char) ((yyvsp[-1].ival) & 0xFF); - processCASbits((yyvsp[0].ival), (yylsp[0]), "FOREIGN KEY", + n->location = (yylsp[(1) - (11)]); + n->pktable = (yyvsp[(7) - (11)].range); + n->fk_attrs = (yyvsp[(4) - (11)].list); + n->pk_attrs = (yyvsp[(8) - (11)].list); + n->fk_matchtype = (yyvsp[(9) - (11)].ival); + n->fk_upd_action = (char) ((yyvsp[(10) - (11)].ival) >> 8); + n->fk_del_action = (char) ((yyvsp[(10) - (11)].ival) & 0xFF); + processCASbits((yyvsp[(11) - (11)].ival), (yylsp[(11) - (11)]), "FOREIGN KEY", &n->deferrable, &n->initdeferred, &n->skip_validation, NULL, yyscanner); n->initially_valid = !n->skip_validation; (yyval.node) = (PGNode *)n; - } -#line 22069 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 387: /* TableElementList: TableElement */ + case 387: #line 674 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 22077 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 388: /* TableElementList: TableElementList ',' TableElement */ + case 388: #line 678 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 22085 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 389: /* key_match: MATCH FULL */ + case 389: #line 685 "third_party/libpg_query/grammar/statements/create.y" - { + { (yyval.ival) = PG_FKCONSTR_MATCH_FULL; - } -#line 22093 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 390: /* key_match: MATCH PARTIAL */ + case 390: #line 689 "third_party/libpg_query/grammar/statements/create.y" - { + { ereport(ERROR, (errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("MATCH PARTIAL not yet implemented"), - parser_errposition((yylsp[-1])))); + parser_errposition((yylsp[(1) - (2)])))); (yyval.ival) = PG_FKCONSTR_MATCH_PARTIAL; - } -#line 22105 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 391: /* key_match: MATCH SIMPLE */ + case 391: #line 697 "third_party/libpg_query/grammar/statements/create.y" - { + { (yyval.ival) = PG_FKCONSTR_MATCH_SIMPLE; - } -#line 22113 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 392: /* key_match: %empty */ + case 392: #line 701 "third_party/libpg_query/grammar/statements/create.y" - { + { (yyval.ival) = PG_FKCONSTR_MATCH_SIMPLE; - } -#line 22121 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 393: /* TableLikeClause: LIKE qualified_name TableLikeOptionList */ + case 393: #line 709 "third_party/libpg_query/grammar/statements/create.y" - { + { PGTableLikeClause *n = makeNode(PGTableLikeClause); - n->relation = (yyvsp[-1].range); - n->options = (yyvsp[0].ival); + n->relation = (yyvsp[(2) - (3)].range); + n->options = (yyvsp[(3) - (3)].ival); (yyval.node) = (PGNode *)n; - } -#line 22132 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 394: /* OptTemp: TEMPORARY */ + case 394: #line 718 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_RELPERSISTENCE_TEMP; } -#line 22138 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 395: /* OptTemp: TEMP */ + case 395: #line 719 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_RELPERSISTENCE_TEMP; } -#line 22144 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 396: /* OptTemp: LOCAL TEMPORARY */ + case 396: #line 720 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_RELPERSISTENCE_TEMP; } -#line 22150 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 397: /* OptTemp: LOCAL TEMP */ + case 397: #line 721 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_RELPERSISTENCE_TEMP; } -#line 22156 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 398: /* OptTemp: GLOBAL TEMPORARY */ + case 398: #line 723 "third_party/libpg_query/grammar/statements/create.y" - { + { ereport(PGWARNING, (errmsg("GLOBAL is deprecated in temporary table creation"), - parser_errposition((yylsp[-1])))); + parser_errposition((yylsp[(1) - (2)])))); (yyval.ival) = PG_RELPERSISTENCE_TEMP; - } -#line 22167 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 399: /* OptTemp: GLOBAL TEMP */ + case 399: #line 730 "third_party/libpg_query/grammar/statements/create.y" - { + { ereport(PGWARNING, (errmsg("GLOBAL is deprecated in temporary table creation"), - parser_errposition((yylsp[-1])))); + parser_errposition((yylsp[(1) - (2)])))); (yyval.ival) = PG_RELPERSISTENCE_TEMP; - } -#line 22178 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 400: /* OptTemp: UNLOGGED */ + case 400: #line 736 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_RELPERSISTENCE_UNLOGGED; } -#line 22184 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_RELPERSISTENCE_UNLOGGED; ;} break; - case 401: /* OptTemp: %empty */ + case 401: #line 737 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = RELPERSISTENCE_PERMANENT; } -#line 22190 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = RELPERSISTENCE_PERMANENT; ;} break; - case 402: /* generated_when: ALWAYS */ + case 402: #line 742 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_ATTRIBUTE_IDENTITY_ALWAYS; } -#line 22196 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_ATTRIBUTE_IDENTITY_ALWAYS; ;} break; - case 403: /* generated_when: BY DEFAULT */ + case 403: #line 743 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = ATTRIBUTE_IDENTITY_BY_DEFAULT; } -#line 22202 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = ATTRIBUTE_IDENTITY_BY_DEFAULT; ;} break; - case 404: /* DropStmt: DROP drop_type_any_name IF_P EXISTS any_name_list opt_drop_behavior */ + case 404: #line 10 "third_party/libpg_query/grammar/statements/drop.y" - { + { PGDropStmt *n = makeNode(PGDropStmt); - n->removeType = (yyvsp[-4].objtype); + n->removeType = (yyvsp[(2) - (6)].objtype); n->missing_ok = true; - n->objects = (yyvsp[-1].list); - n->behavior = (yyvsp[0].dbehavior); + n->objects = (yyvsp[(5) - (6)].list); + n->behavior = (yyvsp[(6) - (6)].dbehavior); n->concurrent = false; (yyval.node) = (PGNode *)n; - } -#line 22216 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 405: /* DropStmt: DROP drop_type_any_name any_name_list opt_drop_behavior */ + case 405: #line 20 "third_party/libpg_query/grammar/statements/drop.y" - { + { PGDropStmt *n = makeNode(PGDropStmt); - n->removeType = (yyvsp[-2].objtype); + n->removeType = (yyvsp[(2) - (4)].objtype); n->missing_ok = false; - n->objects = (yyvsp[-1].list); - n->behavior = (yyvsp[0].dbehavior); + n->objects = (yyvsp[(3) - (4)].list); + n->behavior = (yyvsp[(4) - (4)].dbehavior); n->concurrent = false; (yyval.node) = (PGNode *)n; - } -#line 22230 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 406: /* DropStmt: DROP drop_type_name IF_P EXISTS name_list opt_drop_behavior */ + case 406: #line 30 "third_party/libpg_query/grammar/statements/drop.y" - { + { PGDropStmt *n = makeNode(PGDropStmt); - n->removeType = (yyvsp[-4].objtype); + n->removeType = (yyvsp[(2) - (6)].objtype); n->missing_ok = true; - n->objects = (yyvsp[-1].list); - n->behavior = (yyvsp[0].dbehavior); + n->objects = (yyvsp[(5) - (6)].list); + n->behavior = (yyvsp[(6) - (6)].dbehavior); n->concurrent = false; (yyval.node) = (PGNode *)n; - } -#line 22244 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 407: /* DropStmt: DROP drop_type_name name_list opt_drop_behavior */ + case 407: #line 40 "third_party/libpg_query/grammar/statements/drop.y" - { + { PGDropStmt *n = makeNode(PGDropStmt); - n->removeType = (yyvsp[-2].objtype); + n->removeType = (yyvsp[(2) - (4)].objtype); n->missing_ok = false; - n->objects = (yyvsp[-1].list); - n->behavior = (yyvsp[0].dbehavior); + n->objects = (yyvsp[(3) - (4)].list); + n->behavior = (yyvsp[(4) - (4)].dbehavior); n->concurrent = false; (yyval.node) = (PGNode *)n; - } -#line 22258 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 408: /* DropStmt: DROP drop_type_name_on_any_name name ON any_name opt_drop_behavior */ + case 408: #line 50 "third_party/libpg_query/grammar/statements/drop.y" - { + { PGDropStmt *n = makeNode(PGDropStmt); - n->removeType = (yyvsp[-4].objtype); - n->objects = list_make1(lappend((yyvsp[-1].list), makeString((yyvsp[-3].str)))); - n->behavior = (yyvsp[0].dbehavior); + n->removeType = (yyvsp[(2) - (6)].objtype); + n->objects = list_make1(lappend((yyvsp[(5) - (6)].list), makeString((yyvsp[(3) - (6)].str)))); + n->behavior = (yyvsp[(6) - (6)].dbehavior); n->missing_ok = false; n->concurrent = false; (yyval.node) = (PGNode *) n; - } -#line 22272 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 409: /* DropStmt: DROP drop_type_name_on_any_name IF_P EXISTS name ON any_name opt_drop_behavior */ + case 409: #line 60 "third_party/libpg_query/grammar/statements/drop.y" - { + { PGDropStmt *n = makeNode(PGDropStmt); - n->removeType = (yyvsp[-6].objtype); - n->objects = list_make1(lappend((yyvsp[-1].list), makeString((yyvsp[-3].str)))); - n->behavior = (yyvsp[0].dbehavior); + n->removeType = (yyvsp[(2) - (8)].objtype); + n->objects = list_make1(lappend((yyvsp[(7) - (8)].list), makeString((yyvsp[(5) - (8)].str)))); + n->behavior = (yyvsp[(8) - (8)].dbehavior); n->missing_ok = true; n->concurrent = false; (yyval.node) = (PGNode *) n; - } -#line 22286 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 410: /* drop_type_any_name: TABLE */ + case 410: #line 73 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TABLE; } -#line 22292 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TABLE; ;} break; - case 411: /* drop_type_any_name: SEQUENCE */ + case 411: #line 74 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_SEQUENCE; } -#line 22298 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_SEQUENCE; ;} break; - case 412: /* drop_type_any_name: FUNCTION */ + case 412: #line 75 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_FUNCTION; } -#line 22304 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 413: /* drop_type_any_name: MACRO */ + case 413: #line 76 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_FUNCTION; } -#line 22310 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 414: /* drop_type_any_name: MACRO TABLE */ + case 414: #line 77 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; } -#line 22316 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; ;} break; - case 415: /* drop_type_any_name: VIEW */ + case 415: #line 78 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_VIEW; } -#line 22322 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_VIEW; ;} break; - case 416: /* drop_type_any_name: MATERIALIZED VIEW */ + case 416: #line 79 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_MATVIEW; } -#line 22328 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_MATVIEW; ;} break; - case 417: /* drop_type_any_name: INDEX */ + case 417: #line 80 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_INDEX; } -#line 22334 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_INDEX; ;} break; - case 418: /* drop_type_any_name: FOREIGN TABLE */ + case 418: #line 81 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_FOREIGN_TABLE; } -#line 22340 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FOREIGN_TABLE; ;} break; - case 419: /* drop_type_any_name: COLLATION */ + case 419: #line 82 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_COLLATION; } -#line 22346 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_COLLATION; ;} break; - case 420: /* drop_type_any_name: CONVERSION_P */ + case 420: #line 83 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_CONVERSION; } -#line 22352 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_CONVERSION; ;} break; - case 421: /* drop_type_any_name: SCHEMA */ + case 421: #line 84 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_SCHEMA; } -#line 22358 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_SCHEMA; ;} break; - case 422: /* drop_type_any_name: STATISTICS */ + case 422: #line 85 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_STATISTIC_EXT; } -#line 22364 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_STATISTIC_EXT; ;} break; - case 423: /* drop_type_any_name: TEXT_P SEARCH PARSER */ + case 423: #line 86 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TSPARSER; } -#line 22370 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TSPARSER; ;} break; - case 424: /* drop_type_any_name: TEXT_P SEARCH DICTIONARY */ + case 424: #line 87 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TSDICTIONARY; } -#line 22376 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TSDICTIONARY; ;} break; - case 425: /* drop_type_any_name: TEXT_P SEARCH TEMPLATE */ + case 425: #line 88 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TSTEMPLATE; } -#line 22382 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TSTEMPLATE; ;} break; - case 426: /* drop_type_any_name: TEXT_P SEARCH CONFIGURATION */ + case 426: #line 89 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TSCONFIGURATION; } -#line 22388 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TSCONFIGURATION; ;} break; - case 427: /* drop_type_any_name: TYPE_P */ + case 427: #line 90 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TYPE; } -#line 22394 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TYPE; ;} break; - case 428: /* drop_type_name: ACCESS METHOD */ + case 428: #line 95 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_ACCESS_METHOD; } -#line 22400 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_ACCESS_METHOD; ;} break; - case 429: /* drop_type_name: EVENT TRIGGER */ + case 429: #line 96 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_EVENT_TRIGGER; } -#line 22406 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_EVENT_TRIGGER; ;} break; - case 430: /* drop_type_name: EXTENSION */ + case 430: #line 97 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_EXTENSION; } -#line 22412 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_EXTENSION; ;} break; - case 431: /* drop_type_name: FOREIGN DATA_P WRAPPER */ + case 431: #line 98 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_FDW; } -#line 22418 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FDW; ;} break; - case 432: /* drop_type_name: PUBLICATION */ + case 432: #line 99 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_PUBLICATION; } -#line 22424 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_PUBLICATION; ;} break; - case 433: /* drop_type_name: SERVER */ + case 433: #line 100 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_FOREIGN_SERVER; } -#line 22430 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FOREIGN_SERVER; ;} break; - case 434: /* any_name_list: any_name */ + case 434: #line 105 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.list) = list_make1((yyvsp[0].list)); } -#line 22436 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 435: /* any_name_list: any_name_list ',' any_name */ + case 435: #line 106 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].list)); } -#line 22442 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 436: /* opt_drop_behavior: CASCADE */ + case 436: #line 111 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.dbehavior) = PG_DROP_CASCADE; } -#line 22448 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.dbehavior) = PG_DROP_CASCADE; ;} break; - case 437: /* opt_drop_behavior: RESTRICT */ + case 437: #line 112 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.dbehavior) = PG_DROP_RESTRICT; } -#line 22454 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.dbehavior) = PG_DROP_RESTRICT; ;} break; - case 438: /* opt_drop_behavior: %empty */ + case 438: #line 113 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.dbehavior) = PG_DROP_RESTRICT; /* default */ } -#line 22460 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.dbehavior) = PG_DROP_RESTRICT; /* default */ ;} break; - case 439: /* drop_type_name_on_any_name: POLICY */ + case 439: #line 118 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_POLICY; } -#line 22466 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_POLICY; ;} break; - case 440: /* drop_type_name_on_any_name: RULE */ + case 440: #line 119 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_RULE; } -#line 22472 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_RULE; ;} break; - case 441: /* drop_type_name_on_any_name: TRIGGER */ + case 441: #line 120 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TRIGGER; } -#line 22478 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TRIGGER; ;} break; - case 442: /* CreateFunctionStmt: CREATE_P OptTemp macro_alias qualified_name param_list AS TABLE SelectStmt */ + case 442: #line 9 "third_party/libpg_query/grammar/statements/create_function.y" - { + { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); - (yyvsp[-4].range)->relpersistence = (yyvsp[-6].ival); - n->name = (yyvsp[-4].range); - n->params = (yyvsp[-3].list); + (yyvsp[(4) - (8)].range)->relpersistence = (yyvsp[(2) - (8)].ival); + n->name = (yyvsp[(4) - (8)].range); + n->params = (yyvsp[(5) - (8)].list); n->function = NULL; - n->query = (yyvsp[0].node); + n->query = (yyvsp[(8) - (8)].node); n->onconflict = PG_ERROR_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 22493 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 443: /* CreateFunctionStmt: CREATE_P OptTemp macro_alias IF_P NOT EXISTS qualified_name param_list AS TABLE SelectStmt */ + case 443: #line 21 "third_party/libpg_query/grammar/statements/create_function.y" - { + { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); - (yyvsp[-4].range)->relpersistence = (yyvsp[-9].ival); - n->name = (yyvsp[-4].range); - n->params = (yyvsp[-3].list); + (yyvsp[(7) - (11)].range)->relpersistence = (yyvsp[(2) - (11)].ival); + n->name = (yyvsp[(7) - (11)].range); + n->params = (yyvsp[(8) - (11)].list); n->function = NULL; - n->query = (yyvsp[0].node); + n->query = (yyvsp[(11) - (11)].node); n->onconflict = PG_IGNORE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 22509 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 444: /* CreateFunctionStmt: CREATE_P OR REPLACE OptTemp macro_alias qualified_name param_list AS TABLE SelectStmt */ + case 444: #line 34 "third_party/libpg_query/grammar/statements/create_function.y" - { + { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); - (yyvsp[-4].range)->relpersistence = (yyvsp[-6].ival); - n->name = (yyvsp[-4].range); - n->params = (yyvsp[-3].list); + (yyvsp[(6) - (10)].range)->relpersistence = (yyvsp[(4) - (10)].ival); + n->name = (yyvsp[(6) - (10)].range); + n->params = (yyvsp[(7) - (10)].list); n->function = NULL; - n->query = (yyvsp[0].node); + n->query = (yyvsp[(10) - (10)].node); n->onconflict = PG_REPLACE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 22525 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 445: /* CreateFunctionStmt: CREATE_P OptTemp macro_alias qualified_name param_list AS a_expr */ + case 445: #line 47 "third_party/libpg_query/grammar/statements/create_function.y" - { + { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); - (yyvsp[-3].range)->relpersistence = (yyvsp[-5].ival); - n->name = (yyvsp[-3].range); - n->params = (yyvsp[-2].list); - n->function = (yyvsp[0].node); + (yyvsp[(4) - (7)].range)->relpersistence = (yyvsp[(2) - (7)].ival); + n->name = (yyvsp[(4) - (7)].range); + n->params = (yyvsp[(5) - (7)].list); + n->function = (yyvsp[(7) - (7)].node); n->query = NULL; n->onconflict = PG_ERROR_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 22540 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 446: /* CreateFunctionStmt: CREATE_P OptTemp macro_alias IF_P NOT EXISTS qualified_name param_list AS a_expr */ + case 446: #line 59 "third_party/libpg_query/grammar/statements/create_function.y" - { + { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); - (yyvsp[-3].range)->relpersistence = (yyvsp[-8].ival); - n->name = (yyvsp[-3].range); - n->params = (yyvsp[-2].list); - n->function = (yyvsp[0].node); + (yyvsp[(7) - (10)].range)->relpersistence = (yyvsp[(2) - (10)].ival); + n->name = (yyvsp[(7) - (10)].range); + n->params = (yyvsp[(8) - (10)].list); + n->function = (yyvsp[(10) - (10)].node); n->query = NULL; n->onconflict = PG_IGNORE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 22555 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 447: /* CreateFunctionStmt: CREATE_P OR REPLACE OptTemp macro_alias qualified_name param_list AS a_expr */ + case 447: #line 71 "third_party/libpg_query/grammar/statements/create_function.y" - { + { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); - (yyvsp[-3].range)->relpersistence = (yyvsp[-5].ival); - n->name = (yyvsp[-3].range); - n->params = (yyvsp[-2].list); - n->function = (yyvsp[0].node); + (yyvsp[(6) - (9)].range)->relpersistence = (yyvsp[(4) - (9)].ival); + n->name = (yyvsp[(6) - (9)].range); + n->params = (yyvsp[(7) - (9)].list); + n->function = (yyvsp[(9) - (9)].node); n->query = NULL; n->onconflict = PG_REPLACE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 22570 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 450: /* param_list: '(' ')' */ + case 450: #line 92 "third_party/libpg_query/grammar/statements/create_function.y" - { + { (yyval.list) = NIL; - } -#line 22578 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 451: /* param_list: '(' func_arg_list ')' */ + case 451: #line 96 "third_party/libpg_query/grammar/statements/create_function.y" - { - (yyval.list) = (yyvsp[-1].list); - } -#line 22586 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = (yyvsp[(2) - (3)].list); + ;} break; - case 452: /* UpdateStmt: opt_with_clause UPDATE relation_expr_opt_alias SET set_clause_list_opt_comma from_clause where_or_current_clause returning_clause */ + case 452: #line 12 "third_party/libpg_query/grammar/statements/update.y" - { + { PGUpdateStmt *n = makeNode(PGUpdateStmt); - n->relation = (yyvsp[-5].range); - n->targetList = (yyvsp[-3].list); - n->fromClause = (yyvsp[-2].list); - n->whereClause = (yyvsp[-1].node); - n->returningList = (yyvsp[0].list); - n->withClause = (yyvsp[-7].with); + n->relation = (yyvsp[(3) - (8)].range); + n->targetList = (yyvsp[(5) - (8)].list); + n->fromClause = (yyvsp[(6) - (8)].list); + n->whereClause = (yyvsp[(7) - (8)].node); + n->returningList = (yyvsp[(8) - (8)].list); + n->withClause = (yyvsp[(1) - (8)].with); (yyval.node) = (PGNode *)n; - } -#line 22601 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 453: /* CopyStmt: COPY opt_binary qualified_name opt_column_list opt_oids copy_from opt_program copy_file_name copy_delimiter opt_with copy_options */ + case 453: #line 3 "third_party/libpg_query/grammar/statements/copy.y" - { + { PGCopyStmt *n = makeNode(PGCopyStmt); - n->relation = (yyvsp[-8].range); + n->relation = (yyvsp[(3) - (11)].range); n->query = NULL; - n->attlist = (yyvsp[-7].list); - n->is_from = (yyvsp[-5].boolean); - n->is_program = (yyvsp[-4].boolean); - n->filename = (yyvsp[-3].str); + n->attlist = (yyvsp[(4) - (11)].list); + n->is_from = (yyvsp[(6) - (11)].boolean); + n->is_program = (yyvsp[(7) - (11)].boolean); + n->filename = (yyvsp[(8) - (11)].str); if (n->is_program && n->filename == NULL) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("STDIN/STDOUT not allowed with PROGRAM"), - parser_errposition((yylsp[-3])))); + parser_errposition((yylsp[(8) - (11)])))); n->options = NIL; /* Concatenate user-supplied flags */ - if ((yyvsp[-9].defelt)) - n->options = lappend(n->options, (yyvsp[-9].defelt)); - if ((yyvsp[-6].defelt)) - n->options = lappend(n->options, (yyvsp[-6].defelt)); - if ((yyvsp[-2].defelt)) - n->options = lappend(n->options, (yyvsp[-2].defelt)); - if ((yyvsp[0].list)) - n->options = list_concat(n->options, (yyvsp[0].list)); + if ((yyvsp[(2) - (11)].defelt)) + n->options = lappend(n->options, (yyvsp[(2) - (11)].defelt)); + if ((yyvsp[(5) - (11)].defelt)) + n->options = lappend(n->options, (yyvsp[(5) - (11)].defelt)); + if ((yyvsp[(9) - (11)].defelt)) + n->options = lappend(n->options, (yyvsp[(9) - (11)].defelt)); + if ((yyvsp[(11) - (11)].list)) + n->options = list_concat(n->options, (yyvsp[(11) - (11)].list)); (yyval.node) = (PGNode *)n; - } -#line 22633 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 454: /* CopyStmt: COPY '(' SelectStmt ')' TO opt_program copy_file_name opt_with copy_options */ + case 454: #line 31 "third_party/libpg_query/grammar/statements/copy.y" - { + { PGCopyStmt *n = makeNode(PGCopyStmt); n->relation = NULL; - n->query = (yyvsp[-6].node); + n->query = (yyvsp[(3) - (9)].node); n->attlist = NIL; n->is_from = false; - n->is_program = (yyvsp[-3].boolean); - n->filename = (yyvsp[-2].str); - n->options = (yyvsp[0].list); + n->is_program = (yyvsp[(6) - (9)].boolean); + n->filename = (yyvsp[(7) - (9)].str); + n->options = (yyvsp[(9) - (9)].list); if (n->is_program && n->filename == NULL) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("STDIN/STDOUT not allowed with PROGRAM"), - parser_errposition((yylsp[-4])))); + parser_errposition((yylsp[(5) - (9)])))); (yyval.node) = (PGNode *)n; - } -#line 22656 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 455: /* CopyStmt: COPY FROM DATABASE ColId TO ColId copy_database_flag */ + case 455: #line 50 "third_party/libpg_query/grammar/statements/copy.y" - { + { PGCopyDatabaseStmt *n = makeNode(PGCopyDatabaseStmt); - n->from_database = (yyvsp[-3].str); - n->to_database = (yyvsp[-1].str); - n->copy_database_flag = (yyvsp[0].conststr); + n->from_database = (yyvsp[(4) - (7)].str); + n->to_database = (yyvsp[(6) - (7)].str); + n->copy_database_flag = (yyvsp[(7) - (7)].conststr); (yyval.node) = (PGNode *)n; - } -#line 22668 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 456: /* copy_database_flag: %empty */ + case 456: #line 61 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.conststr) = NULL; } -#line 22674 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = NULL; ;} break; - case 457: /* copy_database_flag: '(' SCHEMA ')' */ + case 457: #line 62 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.conststr) = "schema"; } -#line 22680 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "schema"; ;} break; - case 458: /* copy_database_flag: '(' DATA_P ')' */ + case 458: #line 63 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.conststr) = "data"; } -#line 22686 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "data"; ;} break; - case 459: /* copy_from: FROM */ + case 459: #line 67 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.boolean) = true; } -#line 22692 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 460: /* copy_from: TO */ + case 460: #line 68 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.boolean) = false; } -#line 22698 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 461: /* copy_delimiter: opt_using DELIMITERS Sconst */ + case 461: #line 74 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-1])); - } -#line 22706 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(2) - (3)])); + ;} break; - case 462: /* copy_delimiter: %empty */ + case 462: #line 77 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.defelt) = NULL; } -#line 22712 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.defelt) = NULL; ;} break; - case 463: /* copy_generic_opt_arg_list: copy_generic_opt_arg_list_item */ + case 463: #line 83 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 22720 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 464: /* copy_generic_opt_arg_list: copy_generic_opt_arg_list ',' copy_generic_opt_arg_list_item */ + case 464: #line 87 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 22728 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 465: /* opt_using: USING */ + case 465: #line 94 "third_party/libpg_query/grammar/statements/copy.y" - {} -#line 22734 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 466: /* opt_using: %empty */ + case 466: #line 95 "third_party/libpg_query/grammar/statements/copy.y" - {} -#line 22740 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 467: /* opt_as: AS */ + case 467: #line 99 "third_party/libpg_query/grammar/statements/copy.y" - {} -#line 22746 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 468: /* opt_as: %empty */ + case 468: #line 100 "third_party/libpg_query/grammar/statements/copy.y" - {} -#line 22752 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 469: /* opt_program: PROGRAM */ + case 469: #line 105 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.boolean) = true; } -#line 22758 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 470: /* opt_program: %empty */ + case 470: #line 106 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.boolean) = false; } -#line 22764 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 471: /* copy_options: copy_opt_list */ + case 471: #line 110 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.list) = (yyvsp[0].list); } -#line 22770 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 472: /* copy_options: '(' copy_generic_opt_list ')' */ + case 472: #line 111 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 22776 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 473: /* copy_generic_opt_arg: opt_boolean_or_string */ + case 473: #line 116 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); } -#line 22782 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;} break; - case 474: /* copy_generic_opt_arg: NumericOnly */ + case 474: #line 117 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) (yyvsp[0].value); } -#line 22788 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].value); ;} break; - case 475: /* copy_generic_opt_arg: '*' */ + case 475: #line 118 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) makeNode(PGAStar); } -#line 22794 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeNode(PGAStar); ;} break; - case 476: /* copy_generic_opt_arg: '(' copy_generic_opt_arg_list ')' */ + case 476: #line 119 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) (yyvsp[-1].list); } -#line 22800 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) (yyvsp[(2) - (3)].list); ;} break; - case 477: /* copy_generic_opt_arg: struct_expr */ + case 477: #line 120 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) (yyvsp[0].node); } -#line 22806 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].node); ;} break; - case 478: /* copy_generic_opt_arg: %empty */ + case 478: #line 121 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = NULL; } -#line 22812 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 479: /* copy_generic_opt_elem: ColLabel copy_generic_opt_arg */ + case 479: #line 127 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem((yyvsp[-1].str), (yyvsp[0].node), (yylsp[-1])); - } -#line 22820 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); + ;} break; - case 480: /* opt_oids: WITH OIDS */ + case 480: #line 135 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[-1])); - } -#line 22828 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[(1) - (2)])); + ;} break; - case 481: /* opt_oids: %empty */ + case 481: #line 138 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.defelt) = NULL; } -#line 22834 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.defelt) = NULL; ;} break; - case 482: /* copy_opt_list: copy_opt_list copy_opt_item */ + case 482: #line 143 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].defelt)); } -#line 22840 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} break; - case 483: /* copy_opt_list: %empty */ + case 483: #line 144 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.list) = NIL; } -#line 22846 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 484: /* opt_binary: BINARY */ + case 484: #line 150 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[0])); - } -#line 22854 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[(1) - (1)])); + ;} break; - case 485: /* opt_binary: %empty */ + case 485: #line 153 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.defelt) = NULL; } -#line 22860 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.defelt) = NULL; ;} break; - case 486: /* copy_opt_item: BINARY */ + case 486: #line 159 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[0])); - } -#line 22868 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[(1) - (1)])); + ;} break; - case 487: /* copy_opt_item: OIDS */ + case 487: #line 163 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[0])); - } -#line 22876 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[(1) - (1)])); + ;} break; - case 488: /* copy_opt_item: FREEZE */ + case 488: #line 167 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("freeze", (PGNode *)makeInteger(true), (yylsp[0])); - } -#line 22884 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("freeze", (PGNode *)makeInteger(true), (yylsp[(1) - (1)])); + ;} break; - case 489: /* copy_opt_item: DELIMITER opt_as Sconst */ + case 489: #line 171 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-2])); - } -#line 22892 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)])); + ;} break; - case 490: /* copy_opt_item: NULL_P opt_as Sconst */ + case 490: #line 175 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("null", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-2])); - } -#line 22900 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("null", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)])); + ;} break; - case 491: /* copy_opt_item: CSV */ + case 491: #line 179 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("csv"), (yylsp[0])); - } -#line 22908 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("csv"), (yylsp[(1) - (1)])); + ;} break; - case 492: /* copy_opt_item: HEADER_P */ + case 492: #line 183 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("header", (PGNode *)makeInteger(true), (yylsp[0])); - } -#line 22916 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("header", (PGNode *)makeInteger(true), (yylsp[(1) - (1)])); + ;} break; - case 493: /* copy_opt_item: QUOTE opt_as Sconst */ + case 493: #line 187 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("quote", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-2])); - } -#line 22924 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("quote", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)])); + ;} break; - case 494: /* copy_opt_item: ESCAPE opt_as Sconst */ + case 494: #line 191 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("escape", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-2])); - } -#line 22932 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("escape", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)])); + ;} break; - case 495: /* copy_opt_item: FORCE QUOTE columnList */ + case 495: #line 195 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("force_quote", (PGNode *)(yyvsp[0].list), (yylsp[-2])); - } -#line 22940 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("force_quote", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); + ;} break; - case 496: /* copy_opt_item: FORCE QUOTE '*' */ + case 496: #line 199 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("force_quote", (PGNode *)makeNode(PGAStar), (yylsp[-2])); - } -#line 22948 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("force_quote", (PGNode *)makeNode(PGAStar), (yylsp[(1) - (3)])); + ;} break; - case 497: /* copy_opt_item: PARTITION BY columnList */ + case 497: #line 203 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("partition_by", (PGNode *)(yyvsp[0].list), (yylsp[-2])); - } -#line 22956 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("partition_by", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); + ;} break; - case 498: /* copy_opt_item: PARTITION BY '*' */ + case 498: #line 207 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("partition_by", (PGNode *)makeNode(PGAStar), (yylsp[-2])); - } -#line 22964 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("partition_by", (PGNode *)makeNode(PGAStar), (yylsp[(1) - (3)])); + ;} break; - case 499: /* copy_opt_item: FORCE NOT NULL_P columnList */ + case 499: #line 211 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("force_not_null", (PGNode *)(yyvsp[0].list), (yylsp[-3])); - } -#line 22972 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("force_not_null", (PGNode *)(yyvsp[(4) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 500: /* copy_opt_item: FORCE NULL_P columnList */ + case 500: #line 215 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("force_null", (PGNode *)(yyvsp[0].list), (yylsp[-2])); - } -#line 22980 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("force_null", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); + ;} break; - case 501: /* copy_opt_item: ENCODING Sconst */ + case 501: #line 219 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("encoding", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-1])); - } -#line 22988 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("encoding", (PGNode *)makeString((yyvsp[(2) - (2)].str)), (yylsp[(1) - (2)])); + ;} break; - case 502: /* copy_generic_opt_arg_list_item: opt_boolean_or_string */ + case 502: #line 226 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); } -#line 22994 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;} break; - case 503: /* copy_file_name: Sconst */ + case 503: #line 231 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.str) = (yyvsp[0].str); } -#line 23000 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 504: /* copy_file_name: STDIN */ + case 504: #line 232 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.str) = NULL; } -#line 23006 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 505: /* copy_file_name: STDOUT */ + case 505: #line 233 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.str) = NULL; } -#line 23012 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 506: /* copy_file_name: IDENT '.' ColId */ + case 506: #line 234 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.str) = psprintf("%s.%s", (yyvsp[-2].str), (yyvsp[0].str)); } -#line 23018 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = psprintf("%s.%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)); ;} break; - case 507: /* copy_file_name: IDENT */ + case 507: #line 235 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.str) = (yyvsp[0].str); } -#line 23024 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 508: /* copy_generic_opt_list: copy_generic_opt_elem */ + case 508: #line 242 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.list) = list_make1((yyvsp[0].defelt)); - } -#line 23032 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); + ;} break; - case 509: /* copy_generic_opt_list: copy_generic_opt_list ',' copy_generic_opt_elem */ + case 509: #line 246 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt)); - } -#line 23040 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); + ;} break; - case 512: /* select_with_parens: '(' select_no_parens ')' */ + case 512: #line 52 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 23046 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 513: /* select_with_parens: '(' select_with_parens ')' */ + case 513: #line 53 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 23052 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 514: /* select_with_parens: '(' VariableShowStmt ')' */ + case 514: #line 55 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[-1].node); - } -#line 23060 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(2) - (3)].node); + ;} break; - case 515: /* select_no_parens: simple_select */ + case 515: #line 72 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23066 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 516: /* select_no_parens: select_clause sort_clause */ + case 516: #line 74 "third_party/libpg_query/grammar/statements/select.y" - { - insertSelectOptions((PGSelectStmt *) (yyvsp[-1].node), (yyvsp[0].list), NIL, + { + insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].list), NIL, NULL, NULL, NULL, yyscanner); - (yyval.node) = (yyvsp[-1].node); - } -#line 23077 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(1) - (2)].node); + ;} break; - case 517: /* select_no_parens: select_clause opt_sort_clause for_locking_clause opt_select_limit */ + case 517: #line 81 "third_party/libpg_query/grammar/statements/select.y" - { - insertSelectOptions((PGSelectStmt *) (yyvsp[-3].node), (yyvsp[-2].list), (yyvsp[-1].list), - (PGNode*) list_nth((yyvsp[0].list), 0), (PGNode*) list_nth((yyvsp[0].list), 1), + { + insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].list), (yyvsp[(3) - (4)].list), + (PGNode*) list_nth((yyvsp[(4) - (4)].list), 0), (PGNode*) list_nth((yyvsp[(4) - (4)].list), 1), NULL, yyscanner); - (yyval.node) = (yyvsp[-3].node); - } -#line 23089 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(1) - (4)].node); + ;} break; - case 518: /* select_no_parens: select_clause opt_sort_clause select_limit opt_for_locking_clause */ + case 518: #line 89 "third_party/libpg_query/grammar/statements/select.y" - { - insertSelectOptions((PGSelectStmt *) (yyvsp[-3].node), (yyvsp[-2].list), (yyvsp[0].list), - (PGNode*) list_nth((yyvsp[-1].list), 0), (PGNode*) list_nth((yyvsp[-1].list), 1), + { + insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].list), (yyvsp[(4) - (4)].list), + (PGNode*) list_nth((yyvsp[(3) - (4)].list), 0), (PGNode*) list_nth((yyvsp[(3) - (4)].list), 1), NULL, yyscanner); - (yyval.node) = (yyvsp[-3].node); - } -#line 23101 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(1) - (4)].node); + ;} break; - case 519: /* select_no_parens: with_clause select_clause */ + case 519: #line 97 "third_party/libpg_query/grammar/statements/select.y" - { - insertSelectOptions((PGSelectStmt *) (yyvsp[0].node), NULL, NIL, + { + insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (2)].node), NULL, NIL, NULL, NULL, - (yyvsp[-1].with), + (yyvsp[(1) - (2)].with), yyscanner); - (yyval.node) = (yyvsp[0].node); - } -#line 23113 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(2) - (2)].node); + ;} break; - case 520: /* select_no_parens: with_clause select_clause sort_clause */ + case 520: #line 105 "third_party/libpg_query/grammar/statements/select.y" - { - insertSelectOptions((PGSelectStmt *) (yyvsp[-1].node), (yyvsp[0].list), NIL, + { + insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].list), NIL, NULL, NULL, - (yyvsp[-2].with), + (yyvsp[(1) - (3)].with), yyscanner); - (yyval.node) = (yyvsp[-1].node); - } -#line 23125 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(2) - (3)].node); + ;} break; - case 521: /* select_no_parens: with_clause select_clause opt_sort_clause for_locking_clause opt_select_limit */ + case 521: #line 113 "third_party/libpg_query/grammar/statements/select.y" - { - insertSelectOptions((PGSelectStmt *) (yyvsp[-3].node), (yyvsp[-2].list), (yyvsp[-1].list), - (PGNode*) list_nth((yyvsp[0].list), 0), (PGNode*) list_nth((yyvsp[0].list), 1), - (yyvsp[-4].with), + { + insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (5)].node), (yyvsp[(3) - (5)].list), (yyvsp[(4) - (5)].list), + (PGNode*) list_nth((yyvsp[(5) - (5)].list), 0), (PGNode*) list_nth((yyvsp[(5) - (5)].list), 1), + (yyvsp[(1) - (5)].with), yyscanner); - (yyval.node) = (yyvsp[-3].node); - } -#line 23137 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(2) - (5)].node); + ;} break; - case 522: /* select_no_parens: with_clause select_clause opt_sort_clause select_limit opt_for_locking_clause */ + case 522: #line 121 "third_party/libpg_query/grammar/statements/select.y" - { - insertSelectOptions((PGSelectStmt *) (yyvsp[-3].node), (yyvsp[-2].list), (yyvsp[0].list), - (PGNode*) list_nth((yyvsp[-1].list), 0), (PGNode*) list_nth((yyvsp[-1].list), 1), - (yyvsp[-4].with), + { + insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (5)].node), (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list), + (PGNode*) list_nth((yyvsp[(4) - (5)].list), 0), (PGNode*) list_nth((yyvsp[(4) - (5)].list), 1), + (yyvsp[(1) - (5)].with), yyscanner); - (yyval.node) = (yyvsp[-3].node); - } -#line 23149 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(2) - (5)].node); + ;} break; - case 523: /* select_clause: simple_select */ + case 523: #line 131 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23155 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 524: /* select_clause: select_with_parens */ + case 524: #line 132 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23161 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 525: /* opt_select: SELECT opt_all_clause opt_target_list_opt_comma */ + case 525: #line 160 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[0].list); - } -#line 23169 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = (yyvsp[(3) - (3)].list); + ;} break; - case 526: /* opt_select: %empty */ + case 526: #line 164 "third_party/libpg_query/grammar/statements/select.y" - { + { PGAStar *star = makeNode(PGAStar); (yyval.list) = list_make1(star); - } -#line 23178 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 527: /* simple_select: SELECT opt_all_clause opt_target_list_opt_comma into_clause from_clause where_clause group_clause having_clause window_clause qualify_clause sample_clause */ + case 527: #line 175 "third_party/libpg_query/grammar/statements/select.y" - { + { PGSelectStmt *n = makeNode(PGSelectStmt); - n->targetList = (yyvsp[-8].list); - n->intoClause = (yyvsp[-7].into); - n->fromClause = (yyvsp[-6].list); - n->whereClause = (yyvsp[-5].node); - n->groupClause = (yyvsp[-4].list); - n->havingClause = (yyvsp[-3].node); - n->windowClause = (yyvsp[-2].list); - n->qualifyClause = (yyvsp[-1].node); - n->sampleOptions = (yyvsp[0].node); + n->targetList = (yyvsp[(3) - (11)].list); + n->intoClause = (yyvsp[(4) - (11)].into); + n->fromClause = (yyvsp[(5) - (11)].list); + n->whereClause = (yyvsp[(6) - (11)].node); + n->groupClause = (yyvsp[(7) - (11)].list); + n->havingClause = (yyvsp[(8) - (11)].node); + n->windowClause = (yyvsp[(9) - (11)].list); + n->qualifyClause = (yyvsp[(10) - (11)].node); + n->sampleOptions = (yyvsp[(11) - (11)].node); (yyval.node) = (PGNode *)n; - } -#line 23196 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 528: /* simple_select: SELECT distinct_clause target_list_opt_comma into_clause from_clause where_clause group_clause having_clause window_clause qualify_clause sample_clause */ + case 528: #line 191 "third_party/libpg_query/grammar/statements/select.y" - { + { PGSelectStmt *n = makeNode(PGSelectStmt); - n->distinctClause = (yyvsp[-9].list); - n->targetList = (yyvsp[-8].list); - n->intoClause = (yyvsp[-7].into); - n->fromClause = (yyvsp[-6].list); - n->whereClause = (yyvsp[-5].node); - n->groupClause = (yyvsp[-4].list); - n->havingClause = (yyvsp[-3].node); - n->windowClause = (yyvsp[-2].list); - n->qualifyClause = (yyvsp[-1].node); - n->sampleOptions = (yyvsp[0].node); + n->distinctClause = (yyvsp[(2) - (11)].list); + n->targetList = (yyvsp[(3) - (11)].list); + n->intoClause = (yyvsp[(4) - (11)].into); + n->fromClause = (yyvsp[(5) - (11)].list); + n->whereClause = (yyvsp[(6) - (11)].node); + n->groupClause = (yyvsp[(7) - (11)].list); + n->havingClause = (yyvsp[(8) - (11)].node); + n->windowClause = (yyvsp[(9) - (11)].list); + n->qualifyClause = (yyvsp[(10) - (11)].node); + n->sampleOptions = (yyvsp[(11) - (11)].node); (yyval.node) = (PGNode *)n; - } -#line 23215 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 529: /* simple_select: FROM from_list opt_select into_clause where_clause group_clause having_clause window_clause qualify_clause sample_clause */ + case 529: #line 208 "third_party/libpg_query/grammar/statements/select.y" - { + { PGSelectStmt *n = makeNode(PGSelectStmt); - n->targetList = (yyvsp[-7].list); - n->fromClause = (yyvsp[-8].list); - n->intoClause = (yyvsp[-6].into); - n->whereClause = (yyvsp[-5].node); - n->groupClause = (yyvsp[-4].list); - n->havingClause = (yyvsp[-3].node); - n->windowClause = (yyvsp[-2].list); - n->qualifyClause = (yyvsp[-1].node); - n->sampleOptions = (yyvsp[0].node); + n->targetList = (yyvsp[(3) - (10)].list); + n->fromClause = (yyvsp[(2) - (10)].list); + n->intoClause = (yyvsp[(4) - (10)].into); + n->whereClause = (yyvsp[(5) - (10)].node); + n->groupClause = (yyvsp[(6) - (10)].list); + n->havingClause = (yyvsp[(7) - (10)].node); + n->windowClause = (yyvsp[(8) - (10)].list); + n->qualifyClause = (yyvsp[(9) - (10)].node); + n->sampleOptions = (yyvsp[(10) - (10)].node); (yyval.node) = (PGNode *)n; - } -#line 23233 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 530: /* simple_select: FROM from_list SELECT distinct_clause target_list_opt_comma into_clause where_clause group_clause having_clause window_clause qualify_clause sample_clause */ + case 530: #line 225 "third_party/libpg_query/grammar/statements/select.y" - { + { PGSelectStmt *n = makeNode(PGSelectStmt); - n->targetList = (yyvsp[-7].list); - n->distinctClause = (yyvsp[-8].list); - n->fromClause = (yyvsp[-10].list); - n->intoClause = (yyvsp[-6].into); - n->whereClause = (yyvsp[-5].node); - n->groupClause = (yyvsp[-4].list); - n->havingClause = (yyvsp[-3].node); - n->windowClause = (yyvsp[-2].list); - n->qualifyClause = (yyvsp[-1].node); - n->sampleOptions = (yyvsp[0].node); + n->targetList = (yyvsp[(5) - (12)].list); + n->distinctClause = (yyvsp[(4) - (12)].list); + n->fromClause = (yyvsp[(2) - (12)].list); + n->intoClause = (yyvsp[(6) - (12)].into); + n->whereClause = (yyvsp[(7) - (12)].node); + n->groupClause = (yyvsp[(8) - (12)].list); + n->havingClause = (yyvsp[(9) - (12)].node); + n->windowClause = (yyvsp[(10) - (12)].list); + n->qualifyClause = (yyvsp[(11) - (12)].node); + n->sampleOptions = (yyvsp[(12) - (12)].node); (yyval.node) = (PGNode *)n; - } -#line 23252 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 531: /* simple_select: values_clause_opt_comma */ + case 531: #line 239 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23258 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 532: /* simple_select: TABLE relation_expr */ + case 532: #line 241 "third_party/libpg_query/grammar/statements/select.y" - { + { /* same as SELECT * FROM relation_expr */ PGColumnRef *cr = makeNode(PGColumnRef); PGResTarget *rt = makeNode(PGResTarget); @@ -409790,1973 +413862,1749 @@ YYLTYPE yylloc = yyloc_default; rt->location = -1; n->targetList = list_make1(rt); - n->fromClause = list_make1((yyvsp[0].range)); + n->fromClause = list_make1((yyvsp[(2) - (2)].range)); (yyval.node) = (PGNode *)n; - } -#line 23281 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 533: /* simple_select: select_clause UNION all_or_distinct by_name select_clause */ + case 533: #line 260 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSetOp(PG_SETOP_UNION_BY_NAME, (yyvsp[-2].boolean), (yyvsp[-4].node), (yyvsp[0].node)); - } -#line 23289 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSetOp(PG_SETOP_UNION_BY_NAME, (yyvsp[(3) - (5)].boolean), (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node)); + ;} break; - case 534: /* simple_select: select_clause UNION all_or_distinct select_clause */ + case 534: #line 264 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSetOp(PG_SETOP_UNION, (yyvsp[-1].boolean), (yyvsp[-3].node), (yyvsp[0].node)); - } -#line 23297 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSetOp(PG_SETOP_UNION, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); + ;} break; - case 535: /* simple_select: select_clause INTERSECT all_or_distinct select_clause */ + case 535: #line 268 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSetOp(PG_SETOP_INTERSECT, (yyvsp[-1].boolean), (yyvsp[-3].node), (yyvsp[0].node)); - } -#line 23305 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSetOp(PG_SETOP_INTERSECT, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); + ;} break; - case 536: /* simple_select: select_clause EXCEPT all_or_distinct select_clause */ + case 536: #line 272 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSetOp(PG_SETOP_EXCEPT, (yyvsp[-1].boolean), (yyvsp[-3].node), (yyvsp[0].node)); - } -#line 23313 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSetOp(PG_SETOP_EXCEPT, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); + ;} break; - case 537: /* simple_select: pivot_keyword table_ref USING target_list_opt_comma */ + case 537: #line 276 "third_party/libpg_query/grammar/statements/select.y" - { + { PGSelectStmt *res = makeNode(PGSelectStmt); PGPivotStmt *n = makeNode(PGPivotStmt); - n->source = (yyvsp[-2].node); - n->aggrs = (yyvsp[0].list); + n->source = (yyvsp[(2) - (4)].node); + n->aggrs = (yyvsp[(4) - (4)].list); + n->location = (yylsp[(1) - (4)]); res->pivot = n; (yyval.node) = (PGNode *)res; - } -#line 23326 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 538: /* simple_select: pivot_keyword table_ref USING target_list_opt_comma GROUP_P BY name_list_opt_comma_opt_bracket */ -#line 285 "third_party/libpg_query/grammar/statements/select.y" - { + case 538: +#line 286 "third_party/libpg_query/grammar/statements/select.y" + { PGSelectStmt *res = makeNode(PGSelectStmt); PGPivotStmt *n = makeNode(PGPivotStmt); - n->source = (yyvsp[-5].node); - n->aggrs = (yyvsp[-3].list); - n->groups = (yyvsp[0].list); + n->source = (yyvsp[(2) - (7)].node); + n->aggrs = (yyvsp[(4) - (7)].list); + n->groups = (yyvsp[(7) - (7)].list); + n->location = (yylsp[(1) - (7)]); res->pivot = n; (yyval.node) = (PGNode *)res; - } -#line 23340 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 539: /* simple_select: pivot_keyword table_ref GROUP_P BY name_list_opt_comma_opt_bracket */ -#line 295 "third_party/libpg_query/grammar/statements/select.y" - { + case 539: +#line 297 "third_party/libpg_query/grammar/statements/select.y" + { PGSelectStmt *res = makeNode(PGSelectStmt); PGPivotStmt *n = makeNode(PGPivotStmt); - n->source = (yyvsp[-3].node); - n->groups = (yyvsp[0].list); + n->source = (yyvsp[(2) - (5)].node); + n->groups = (yyvsp[(5) - (5)].list); + n->location = (yylsp[(1) - (5)]); res->pivot = n; (yyval.node) = (PGNode *)res; - } -#line 23353 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 540: /* simple_select: pivot_keyword table_ref ON pivot_column_list */ -#line 304 "third_party/libpg_query/grammar/statements/select.y" - { + case 540: +#line 307 "third_party/libpg_query/grammar/statements/select.y" + { PGSelectStmt *res = makeNode(PGSelectStmt); PGPivotStmt *n = makeNode(PGPivotStmt); - n->source = (yyvsp[-2].node); - n->columns = (yyvsp[0].list); + n->source = (yyvsp[(2) - (4)].node); + n->columns = (yyvsp[(4) - (4)].list); res->pivot = n; (yyval.node) = (PGNode *)res; - } -#line 23366 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 541: /* simple_select: pivot_keyword table_ref ON pivot_column_list GROUP_P BY name_list_opt_comma_opt_bracket */ -#line 313 "third_party/libpg_query/grammar/statements/select.y" - { + case 541: +#line 316 "third_party/libpg_query/grammar/statements/select.y" + { PGSelectStmt *res = makeNode(PGSelectStmt); PGPivotStmt *n = makeNode(PGPivotStmt); - n->source = (yyvsp[-5].node); - n->columns = (yyvsp[-3].list); - n->groups = (yyvsp[0].list); + n->source = (yyvsp[(2) - (7)].node); + n->columns = (yyvsp[(4) - (7)].list); + n->groups = (yyvsp[(7) - (7)].list); + n->location = (yylsp[(1) - (7)]); res->pivot = n; (yyval.node) = (PGNode *)res; - } -#line 23380 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 542: /* simple_select: pivot_keyword table_ref ON pivot_column_list USING target_list_opt_comma */ -#line 323 "third_party/libpg_query/grammar/statements/select.y" - { + case 542: +#line 327 "third_party/libpg_query/grammar/statements/select.y" + { PGSelectStmt *res = makeNode(PGSelectStmt); PGPivotStmt *n = makeNode(PGPivotStmt); - n->source = (yyvsp[-4].node); - n->columns = (yyvsp[-2].list); - n->aggrs = (yyvsp[0].list); + n->source = (yyvsp[(2) - (6)].node); + n->columns = (yyvsp[(4) - (6)].list); + n->aggrs = (yyvsp[(6) - (6)].list); + n->location = (yylsp[(1) - (6)]); res->pivot = n; (yyval.node) = (PGNode *)res; - } -#line 23394 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 543: /* simple_select: pivot_keyword table_ref ON pivot_column_list USING target_list_opt_comma GROUP_P BY name_list_opt_comma_opt_bracket */ -#line 333 "third_party/libpg_query/grammar/statements/select.y" - { + case 543: +#line 338 "third_party/libpg_query/grammar/statements/select.y" + { PGSelectStmt *res = makeNode(PGSelectStmt); PGPivotStmt *n = makeNode(PGPivotStmt); - n->source = (yyvsp[-7].node); - n->columns = (yyvsp[-5].list); - n->aggrs = (yyvsp[-3].list); - n->groups = (yyvsp[0].list); + n->source = (yyvsp[(2) - (9)].node); + n->columns = (yyvsp[(4) - (9)].list); + n->aggrs = (yyvsp[(6) - (9)].list); + n->groups = (yyvsp[(9) - (9)].list); + n->location = (yylsp[(1) - (9)]); res->pivot = n; (yyval.node) = (PGNode *)res; - } -#line 23409 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 544: /* simple_select: unpivot_keyword table_ref ON target_list_opt_comma INTO NAME_P name value_or_values name_list_opt_comma_opt_bracket */ -#line 344 "third_party/libpg_query/grammar/statements/select.y" - { + case 544: +#line 350 "third_party/libpg_query/grammar/statements/select.y" + { PGSelectStmt *res = makeNode(PGSelectStmt); PGPivotStmt *n = makeNode(PGPivotStmt); - n->source = (yyvsp[-7].node); - n->unpivots = (yyvsp[0].list); + n->source = (yyvsp[(2) - (9)].node); + n->unpivots = (yyvsp[(9) - (9)].list); + n->location = (yylsp[(1) - (9)]); PGPivot *piv = makeNode(PGPivot); - piv->unpivot_columns = list_make1(makeString((yyvsp[-2].str))); - piv->pivot_value = (yyvsp[-5].list); + piv->unpivot_columns = list_make1(makeString((yyvsp[(7) - (9)].str))); + piv->pivot_value = (yyvsp[(4) - (9)].list); n->columns = list_make1(piv); res->pivot = n; (yyval.node) = (PGNode *)res; - } -#line 23427 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 545: /* simple_select: unpivot_keyword table_ref ON target_list_opt_comma */ -#line 358 "third_party/libpg_query/grammar/statements/select.y" - { + case 545: +#line 365 "third_party/libpg_query/grammar/statements/select.y" + { PGSelectStmt *res = makeNode(PGSelectStmt); PGPivotStmt *n = makeNode(PGPivotStmt); - n->source = (yyvsp[-2].node); + n->source = (yyvsp[(2) - (4)].node); n->unpivots = list_make1(makeString("value")); + n->location = (yylsp[(1) - (4)]); PGPivot *piv = makeNode(PGPivot); piv->unpivot_columns = list_make1(makeString("name")); - piv->pivot_value = (yyvsp[0].list); + piv->pivot_value = (yyvsp[(4) - (4)].list); n->columns = list_make1(piv); res->pivot = n; (yyval.node) = (PGNode *)res; - } -#line 23445 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 552: /* pivot_column_entry: b_expr */ -#line 387 "third_party/libpg_query/grammar/statements/select.y" - { + case 552: +#line 395 "third_party/libpg_query/grammar/statements/select.y" + { PGPivot *n = makeNode(PGPivot); - n->pivot_columns = list_make1((yyvsp[0].node)); + n->pivot_columns = list_make1((yyvsp[(1) - (1)].node)); (yyval.node) = (PGNode *) n; - } -#line 23455 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 553: /* pivot_column_entry: b_expr IN_P '(' select_no_parens ')' */ -#line 393 "third_party/libpg_query/grammar/statements/select.y" - { + case 553: +#line 401 "third_party/libpg_query/grammar/statements/select.y" + { PGPivot *n = makeNode(PGPivot); - n->pivot_columns = list_make1((yyvsp[-4].node)); - n->subquery = (yyvsp[-1].node); + n->pivot_columns = list_make1((yyvsp[(1) - (5)].node)); + n->subquery = (yyvsp[(4) - (5)].node); (yyval.node) = (PGNode *) n; - } -#line 23466 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 554: /* pivot_column_entry: single_pivot_value */ -#line 399 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23472 "third_party/libpg_query/grammar/grammar_out.cpp" + case 554: +#line 407 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 555: /* pivot_column_list_internal: pivot_column_entry */ -#line 403 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 23478 "third_party/libpg_query/grammar/grammar_out.cpp" + case 555: +#line 411 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 556: /* pivot_column_list_internal: pivot_column_list_internal ',' pivot_column_entry */ -#line 404 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 23484 "third_party/libpg_query/grammar/grammar_out.cpp" + case 556: +#line 412 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 557: /* pivot_column_list: pivot_column_list_internal */ -#line 408 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 23490 "third_party/libpg_query/grammar/grammar_out.cpp" + case 557: +#line 416 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 558: /* pivot_column_list: pivot_column_list_internal ',' */ -#line 409 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 23496 "third_party/libpg_query/grammar/grammar_out.cpp" + case 558: +#line 417 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 559: /* with_clause: WITH cte_list */ -#line 424 "third_party/libpg_query/grammar/statements/select.y" - { + case 559: +#line 432 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.with) = makeNode(PGWithClause); - (yyval.with)->ctes = (yyvsp[0].list); + (yyval.with)->ctes = (yyvsp[(2) - (2)].list); (yyval.with)->recursive = false; - (yyval.with)->location = (yylsp[-1]); - } -#line 23507 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.with)->location = (yylsp[(1) - (2)]); + ;} break; - case 560: /* with_clause: WITH_LA cte_list */ -#line 431 "third_party/libpg_query/grammar/statements/select.y" - { + case 560: +#line 439 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.with) = makeNode(PGWithClause); - (yyval.with)->ctes = (yyvsp[0].list); + (yyval.with)->ctes = (yyvsp[(2) - (2)].list); (yyval.with)->recursive = false; - (yyval.with)->location = (yylsp[-1]); - } -#line 23518 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.with)->location = (yylsp[(1) - (2)]); + ;} break; - case 561: /* with_clause: WITH RECURSIVE cte_list */ -#line 438 "third_party/libpg_query/grammar/statements/select.y" - { + case 561: +#line 446 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.with) = makeNode(PGWithClause); - (yyval.with)->ctes = (yyvsp[0].list); + (yyval.with)->ctes = (yyvsp[(3) - (3)].list); (yyval.with)->recursive = true; - (yyval.with)->location = (yylsp[-2]); - } -#line 23529 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.with)->location = (yylsp[(1) - (3)]); + ;} break; - case 562: /* cte_list: common_table_expr */ -#line 447 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 23535 "third_party/libpg_query/grammar/grammar_out.cpp" + case 562: +#line 455 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 563: /* cte_list: cte_list ',' common_table_expr */ -#line 448 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 23541 "third_party/libpg_query/grammar/grammar_out.cpp" + case 563: +#line 456 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 564: /* common_table_expr: name opt_name_list AS opt_materialized '(' PreparableStmt ')' */ -#line 452 "third_party/libpg_query/grammar/statements/select.y" - { + case 564: +#line 460 "third_party/libpg_query/grammar/statements/select.y" + { PGCommonTableExpr *n = makeNode(PGCommonTableExpr); - n->ctename = (yyvsp[-6].str); - n->aliascolnames = (yyvsp[-5].list); - n->ctematerialized = (yyvsp[-3].ctematerialize); - n->ctequery = (yyvsp[-1].node); - n->location = (yylsp[-6]); + n->ctename = (yyvsp[(1) - (7)].str); + n->aliascolnames = (yyvsp[(2) - (7)].list); + n->ctematerialized = (yyvsp[(4) - (7)].ctematerialize); + n->ctequery = (yyvsp[(6) - (7)].node); + n->location = (yylsp[(1) - (7)]); (yyval.node) = (PGNode *) n; - } -#line 23555 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 565: /* opt_materialized: MATERIALIZED */ -#line 464 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ctematerialize) = PGCTEMaterializeAlways; } -#line 23561 "third_party/libpg_query/grammar/grammar_out.cpp" + case 565: +#line 472 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ctematerialize) = PGCTEMaterializeAlways; ;} break; - case 566: /* opt_materialized: NOT MATERIALIZED */ -#line 465 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ctematerialize) = PGCTEMaterializeNever; } -#line 23567 "third_party/libpg_query/grammar/grammar_out.cpp" + case 566: +#line 473 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ctematerialize) = PGCTEMaterializeNever; ;} break; - case 567: /* opt_materialized: %empty */ -#line 466 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ctematerialize) = PGCTEMaterializeDefault; } -#line 23573 "third_party/libpg_query/grammar/grammar_out.cpp" + case 567: +#line 474 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ctematerialize) = PGCTEMaterializeDefault; ;} break; - case 568: /* into_clause: INTO OptTempTableName */ -#line 471 "third_party/libpg_query/grammar/statements/select.y" - { + case 568: +#line 479 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.into) = makeNode(PGIntoClause); - (yyval.into)->rel = (yyvsp[0].range); + (yyval.into)->rel = (yyvsp[(2) - (2)].range); (yyval.into)->colNames = NIL; (yyval.into)->options = NIL; (yyval.into)->onCommit = PG_ONCOMMIT_NOOP; (yyval.into)->viewQuery = NULL; (yyval.into)->skipData = false; - } -#line 23587 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 569: /* into_clause: %empty */ -#line 481 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.into) = NULL; } -#line 23593 "third_party/libpg_query/grammar/grammar_out.cpp" + case 569: +#line 489 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.into) = NULL; ;} break; - case 570: /* OptTempTableName: TEMPORARY opt_table qualified_name */ -#line 490 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + case 570: +#line 498 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.range) = (yyvsp[(3) - (3)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP; - } -#line 23602 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 571: /* OptTempTableName: TEMP opt_table qualified_name */ -#line 495 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + case 571: +#line 503 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.range) = (yyvsp[(3) - (3)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP; - } -#line 23611 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 572: /* OptTempTableName: LOCAL TEMPORARY opt_table qualified_name */ -#line 500 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + case 572: +#line 508 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.range) = (yyvsp[(4) - (4)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP; - } -#line 23620 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 573: /* OptTempTableName: LOCAL TEMP opt_table qualified_name */ -#line 505 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + case 573: +#line 513 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.range) = (yyvsp[(4) - (4)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP; - } -#line 23629 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 574: /* OptTempTableName: GLOBAL TEMPORARY opt_table qualified_name */ -#line 510 "third_party/libpg_query/grammar/statements/select.y" - { + case 574: +#line 518 "third_party/libpg_query/grammar/statements/select.y" + { ereport(PGWARNING, (errmsg("GLOBAL is deprecated in temporary table creation"), - parser_errposition((yylsp[-3])))); - (yyval.range) = (yyvsp[0].range); + parser_errposition((yylsp[(1) - (4)])))); + (yyval.range) = (yyvsp[(4) - (4)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP; - } -#line 23641 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 575: /* OptTempTableName: GLOBAL TEMP opt_table qualified_name */ -#line 518 "third_party/libpg_query/grammar/statements/select.y" - { + case 575: +#line 526 "third_party/libpg_query/grammar/statements/select.y" + { ereport(PGWARNING, (errmsg("GLOBAL is deprecated in temporary table creation"), - parser_errposition((yylsp[-3])))); - (yyval.range) = (yyvsp[0].range); + parser_errposition((yylsp[(1) - (4)])))); + (yyval.range) = (yyvsp[(4) - (4)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP; - } -#line 23653 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 576: /* OptTempTableName: UNLOGGED opt_table qualified_name */ -#line 526 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + case 576: +#line 534 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.range) = (yyvsp[(3) - (3)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_UNLOGGED; - } -#line 23662 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 577: /* OptTempTableName: TABLE qualified_name */ -#line 531 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + case 577: +#line 539 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.range) = (yyvsp[(2) - (2)].range); (yyval.range)->relpersistence = RELPERSISTENCE_PERMANENT; - } -#line 23671 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 578: /* OptTempTableName: qualified_name */ -#line 536 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + case 578: +#line 544 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.range) = (yyvsp[(1) - (1)].range); (yyval.range)->relpersistence = RELPERSISTENCE_PERMANENT; - } -#line 23680 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 579: /* opt_table: TABLE */ -#line 542 "third_party/libpg_query/grammar/statements/select.y" - {} -#line 23686 "third_party/libpg_query/grammar/grammar_out.cpp" + case 579: +#line 550 "third_party/libpg_query/grammar/statements/select.y" + {;} break; - case 580: /* opt_table: %empty */ -#line 543 "third_party/libpg_query/grammar/statements/select.y" - {} -#line 23692 "third_party/libpg_query/grammar/grammar_out.cpp" + case 580: +#line 551 "third_party/libpg_query/grammar/statements/select.y" + {;} break; - case 581: /* all_or_distinct: ALL */ -#line 547 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 23698 "third_party/libpg_query/grammar/grammar_out.cpp" + case 581: +#line 555 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = true; ;} break; - case 582: /* all_or_distinct: DISTINCT */ -#line 548 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 23704 "third_party/libpg_query/grammar/grammar_out.cpp" + case 582: +#line 556 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = false; ;} break; - case 583: /* all_or_distinct: %empty */ -#line 549 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 23710 "third_party/libpg_query/grammar/grammar_out.cpp" + case 583: +#line 557 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = false; ;} break; - case 584: /* by_name: BY NAME_P */ -#line 553 "third_party/libpg_query/grammar/statements/select.y" - { } -#line 23716 "third_party/libpg_query/grammar/grammar_out.cpp" + case 584: +#line 561 "third_party/libpg_query/grammar/statements/select.y" + { ;} break; - case 585: /* distinct_clause: DISTINCT */ -#line 560 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(NIL); } -#line 23722 "third_party/libpg_query/grammar/grammar_out.cpp" + case 585: +#line 568 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(NIL); ;} break; - case 586: /* distinct_clause: DISTINCT ON '(' expr_list_opt_comma ')' */ -#line 561 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 23728 "third_party/libpg_query/grammar/grammar_out.cpp" + case 586: +#line 569 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(4) - (5)].list); ;} break; - case 587: /* opt_all_clause: ALL */ -#line 565 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL;} -#line 23734 "third_party/libpg_query/grammar/grammar_out.cpp" + case 587: +#line 573 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL;;} break; - case 588: /* opt_all_clause: %empty */ -#line 566 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 23740 "third_party/libpg_query/grammar/grammar_out.cpp" + case 588: +#line 574 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 589: /* opt_ignore_nulls: IGNORE_P NULLS_P */ -#line 570 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true;} -#line 23746 "third_party/libpg_query/grammar/grammar_out.cpp" + case 589: +#line 578 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = true;;} break; - case 590: /* opt_ignore_nulls: RESPECT_P NULLS_P */ -#line 571 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false;} -#line 23752 "third_party/libpg_query/grammar/grammar_out.cpp" + case 590: +#line 579 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = false;;} break; - case 591: /* opt_ignore_nulls: %empty */ -#line 572 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 23758 "third_party/libpg_query/grammar/grammar_out.cpp" + case 591: +#line 580 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = false; ;} break; - case 592: /* opt_sort_clause: sort_clause */ -#line 576 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list);} -#line 23764 "third_party/libpg_query/grammar/grammar_out.cpp" + case 592: +#line 584 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list);;} break; - case 593: /* opt_sort_clause: %empty */ -#line 577 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 23770 "third_party/libpg_query/grammar/grammar_out.cpp" + case 593: +#line 585 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 594: /* sort_clause: ORDER BY sortby_list */ -#line 581 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 23776 "third_party/libpg_query/grammar/grammar_out.cpp" + case 594: +#line 589 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 595: /* sort_clause: ORDER BY ALL opt_asc_desc opt_nulls_order */ -#line 583 "third_party/libpg_query/grammar/statements/select.y" - { + case 595: +#line 591 "third_party/libpg_query/grammar/statements/select.y" + { PGSortBy *sort = makeNode(PGSortBy); PGAStar *star = makeNode(PGAStar); star->columns = true; - star->location = (yylsp[-2]); + star->location = (yylsp[(3) - (5)]); sort->node = (PGNode *) star; - sort->sortby_dir = (yyvsp[-1].sortorder); - sort->sortby_nulls = (yyvsp[0].nullorder); + sort->sortby_dir = (yyvsp[(4) - (5)].sortorder); + sort->sortby_nulls = (yyvsp[(5) - (5)].nullorder); sort->useOp = NIL; sort->location = -1; /* no operator */ (yyval.list) = list_make1(sort); - } -#line 23793 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 596: /* sortby_list: sortby */ -#line 598 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].sortby)); } -#line 23799 "third_party/libpg_query/grammar/grammar_out.cpp" + case 596: +#line 606 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].sortby)); ;} break; - case 597: /* sortby_list: sortby_list ',' sortby */ -#line 599 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].sortby)); } -#line 23805 "third_party/libpg_query/grammar/grammar_out.cpp" + case 597: +#line 607 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].sortby)); ;} break; - case 598: /* sortby: a_expr USING qual_all_Op opt_nulls_order */ -#line 603 "third_party/libpg_query/grammar/statements/select.y" - { + case 598: +#line 611 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.sortby) = makeNode(PGSortBy); - (yyval.sortby)->node = (yyvsp[-3].node); + (yyval.sortby)->node = (yyvsp[(1) - (4)].node); (yyval.sortby)->sortby_dir = SORTBY_USING; - (yyval.sortby)->sortby_nulls = (yyvsp[0].nullorder); - (yyval.sortby)->useOp = (yyvsp[-1].list); - (yyval.sortby)->location = (yylsp[-1]); - } -#line 23818 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.sortby)->sortby_nulls = (yyvsp[(4) - (4)].nullorder); + (yyval.sortby)->useOp = (yyvsp[(3) - (4)].list); + (yyval.sortby)->location = (yylsp[(3) - (4)]); + ;} break; - case 599: /* sortby: a_expr opt_asc_desc opt_nulls_order */ -#line 612 "third_party/libpg_query/grammar/statements/select.y" - { + case 599: +#line 620 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.sortby) = makeNode(PGSortBy); - (yyval.sortby)->node = (yyvsp[-2].node); - (yyval.sortby)->sortby_dir = (yyvsp[-1].sortorder); - (yyval.sortby)->sortby_nulls = (yyvsp[0].nullorder); + (yyval.sortby)->node = (yyvsp[(1) - (3)].node); + (yyval.sortby)->sortby_dir = (yyvsp[(2) - (3)].sortorder); + (yyval.sortby)->sortby_nulls = (yyvsp[(3) - (3)].nullorder); (yyval.sortby)->useOp = NIL; (yyval.sortby)->location = -1; /* no operator */ - } -#line 23831 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 600: /* opt_asc_desc: ASC_P */ -#line 622 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.sortorder) = PG_SORTBY_ASC; } -#line 23837 "third_party/libpg_query/grammar/grammar_out.cpp" + case 600: +#line 630 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.sortorder) = PG_SORTBY_ASC; ;} break; - case 601: /* opt_asc_desc: DESC_P */ -#line 623 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.sortorder) = PG_SORTBY_DESC; } -#line 23843 "third_party/libpg_query/grammar/grammar_out.cpp" + case 601: +#line 631 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.sortorder) = PG_SORTBY_DESC; ;} break; - case 602: /* opt_asc_desc: %empty */ -#line 624 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.sortorder) = PG_SORTBY_DEFAULT; } -#line 23849 "third_party/libpg_query/grammar/grammar_out.cpp" + case 602: +#line 632 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.sortorder) = PG_SORTBY_DEFAULT; ;} break; - case 603: /* opt_nulls_order: NULLS_LA FIRST_P */ -#line 627 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.nullorder) = PG_SORTBY_NULLS_FIRST; } -#line 23855 "third_party/libpg_query/grammar/grammar_out.cpp" + case 603: +#line 635 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.nullorder) = PG_SORTBY_NULLS_FIRST; ;} break; - case 604: /* opt_nulls_order: NULLS_LA LAST_P */ -#line 628 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.nullorder) = PG_SORTBY_NULLS_LAST; } -#line 23861 "third_party/libpg_query/grammar/grammar_out.cpp" + case 604: +#line 636 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.nullorder) = PG_SORTBY_NULLS_LAST; ;} break; - case 605: /* opt_nulls_order: %empty */ -#line 629 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.nullorder) = PG_SORTBY_NULLS_DEFAULT; } -#line 23867 "third_party/libpg_query/grammar/grammar_out.cpp" + case 605: +#line 637 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.nullorder) = PG_SORTBY_NULLS_DEFAULT; ;} break; - case 606: /* select_limit: limit_clause offset_clause */ -#line 633 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[0].node), (yyvsp[-1].node)); } -#line 23873 "third_party/libpg_query/grammar/grammar_out.cpp" + case 606: +#line 641 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make2((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].node)); ;} break; - case 607: /* select_limit: offset_clause limit_clause */ -#line 634 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[-1].node), (yyvsp[0].node)); } -#line 23879 "third_party/libpg_query/grammar/grammar_out.cpp" + case 607: +#line 642 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); ;} break; - case 608: /* select_limit: limit_clause */ -#line 635 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2(NULL, (yyvsp[0].node)); } -#line 23885 "third_party/libpg_query/grammar/grammar_out.cpp" + case 608: +#line 643 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make2(NULL, (yyvsp[(1) - (1)].node)); ;} break; - case 609: /* select_limit: offset_clause */ -#line 636 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[0].node), NULL); } -#line 23891 "third_party/libpg_query/grammar/grammar_out.cpp" + case 609: +#line 644 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make2((yyvsp[(1) - (1)].node), NULL); ;} break; - case 610: /* opt_select_limit: select_limit */ -#line 640 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 23897 "third_party/libpg_query/grammar/grammar_out.cpp" + case 610: +#line 648 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 611: /* opt_select_limit: %empty */ -#line 641 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2(NULL,NULL); } -#line 23903 "third_party/libpg_query/grammar/grammar_out.cpp" + case 611: +#line 649 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make2(NULL,NULL); ;} break; - case 612: /* limit_clause: LIMIT select_limit_value */ -#line 646 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23909 "third_party/libpg_query/grammar/grammar_out.cpp" + case 612: +#line 654 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 613: /* limit_clause: LIMIT select_limit_value ',' select_offset_value */ -#line 648 "third_party/libpg_query/grammar/statements/select.y" - { + case 613: +#line 656 "third_party/libpg_query/grammar/statements/select.y" + { /* Disabled because it was too confusing, bjm 2002-02-18 */ ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("LIMIT #,# syntax is not supported"), errhint("Use separate LIMIT and OFFSET clauses."), - parser_errposition((yylsp[-3])))); - } -#line 23922 "third_party/libpg_query/grammar/grammar_out.cpp" + parser_errposition((yylsp[(1) - (4)])))); + ;} break; - case 614: /* limit_clause: FETCH first_or_next select_fetch_first_value row_or_rows ONLY */ -#line 664 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-2].node); } -#line 23928 "third_party/libpg_query/grammar/grammar_out.cpp" + case 614: +#line 672 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(3) - (5)].node); ;} break; - case 615: /* limit_clause: FETCH first_or_next row_or_rows ONLY */ -#line 666 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeIntConst(1, -1); } -#line 23934 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 616: /* offset_clause: OFFSET select_offset_value */ -#line 671 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23940 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 617: /* offset_clause: OFFSET select_fetch_first_value row_or_rows */ + case 615: #line 674 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 23946 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeIntConst(1, -1); ;} break; - case 618: /* sample_count: FCONST '%' */ -#line 682 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeFloat((yyvsp[-1].str)), true); - } -#line 23954 "third_party/libpg_query/grammar/grammar_out.cpp" + case 616: +#line 679 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 619: /* sample_count: ICONST '%' */ -#line 686 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeInteger((yyvsp[-1].ival)), true); - } -#line 23962 "third_party/libpg_query/grammar/grammar_out.cpp" + case 617: +#line 682 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 620: /* sample_count: FCONST PERCENT */ + case 618: #line 690 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeFloat((yyvsp[-1].str)), true); - } -#line 23970 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleSize(makeFloat((yyvsp[(1) - (2)].str)), true); + ;} break; - case 621: /* sample_count: ICONST PERCENT */ + case 619: #line 694 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeInteger((yyvsp[-1].ival)), true); - } -#line 23978 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (2)].ival)), true); + ;} break; - case 622: /* sample_count: ICONST */ + case 620: #line 698 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeInteger((yyvsp[0].ival)), false); - } -#line 23986 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleSize(makeFloat((yyvsp[(1) - (2)].str)), true); + ;} break; - case 623: /* sample_count: ICONST ROWS */ + case 621: #line 702 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeInteger((yyvsp[-1].ival)), false); - } -#line 23994 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (2)].ival)), true); + ;} break; - case 624: /* sample_clause: USING SAMPLE tablesample_entry */ -#line 709 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 24002 "third_party/libpg_query/grammar/grammar_out.cpp" + case 622: +#line 706 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (1)].ival)), false); + ;} break; - case 625: /* sample_clause: %empty */ -#line 713 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24008 "third_party/libpg_query/grammar/grammar_out.cpp" + case 623: +#line 710 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (2)].ival)), false); + ;} break; - case 626: /* opt_sample_func: ColId */ -#line 720 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 24014 "third_party/libpg_query/grammar/grammar_out.cpp" + case 624: +#line 717 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (yyvsp[(3) - (3)].node); + ;} break; - case 627: /* opt_sample_func: %empty */ + case 625: #line 721 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = NULL; } -#line 24020 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 628: /* tablesample_entry: opt_sample_func '(' sample_count ')' opt_repeatable_clause */ -#line 726 "third_party/libpg_query/grammar/statements/select.y" - { - int seed = (yyvsp[0].ival); - (yyval.node) = makeSampleOptions((yyvsp[-2].node), (yyvsp[-4].str), &seed, (yylsp[-4])); - } -#line 24029 "third_party/libpg_query/grammar/grammar_out.cpp" + case 626: +#line 728 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 629: /* tablesample_entry: sample_count */ -#line 731 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleOptions((yyvsp[0].node), NULL, NULL, (yylsp[0])); - } -#line 24037 "third_party/libpg_query/grammar/grammar_out.cpp" + case 627: +#line 729 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = NULL; ;} break; - case 630: /* tablesample_entry: sample_count '(' ColId ')' */ -#line 735 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleOptions((yyvsp[-3].node), (yyvsp[-1].str), NULL, (yylsp[-3])); - } -#line 24045 "third_party/libpg_query/grammar/grammar_out.cpp" + case 628: +#line 734 "third_party/libpg_query/grammar/statements/select.y" + { + int seed = (yyvsp[(5) - (5)].ival); + (yyval.node) = makeSampleOptions((yyvsp[(3) - (5)].node), (yyvsp[(1) - (5)].str), &seed, (yylsp[(1) - (5)])); + ;} break; - case 631: /* tablesample_entry: sample_count '(' ColId ',' ICONST ')' */ + case 629: #line 739 "third_party/libpg_query/grammar/statements/select.y" - { - int seed = (yyvsp[-1].ival); - (yyval.node) = makeSampleOptions((yyvsp[-5].node), (yyvsp[-3].str), &seed, (yylsp[-5])); - } -#line 24054 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 632: /* tablesample_clause: TABLESAMPLE tablesample_entry */ -#line 747 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 24062 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleOptions((yyvsp[(1) - (1)].node), NULL, NULL, (yylsp[(1) - (1)])); + ;} break; - case 633: /* opt_tablesample_clause: tablesample_clause */ -#line 753 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24068 "third_party/libpg_query/grammar/grammar_out.cpp" + case 630: +#line 743 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeSampleOptions((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].str), NULL, (yylsp[(1) - (4)])); + ;} break; - case 634: /* opt_tablesample_clause: %empty */ -#line 754 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24074 "third_party/libpg_query/grammar/grammar_out.cpp" + case 631: +#line 747 "third_party/libpg_query/grammar/statements/select.y" + { + int seed = (yyvsp[(5) - (6)].ival); + (yyval.node) = makeSampleOptions((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].str), &seed, (yylsp[(1) - (6)])); + ;} break; - case 635: /* opt_repeatable_clause: REPEATABLE '(' ICONST ')' */ -#line 759 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = (yyvsp[-1].ival); } -#line 24080 "third_party/libpg_query/grammar/grammar_out.cpp" + case 632: +#line 755 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (yyvsp[(2) - (2)].node); + ;} break; - case 636: /* opt_repeatable_clause: %empty */ -#line 760 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = -1; } -#line 24086 "third_party/libpg_query/grammar/grammar_out.cpp" + case 633: +#line 761 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 637: /* select_limit_value: a_expr */ -#line 764 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24092 "third_party/libpg_query/grammar/grammar_out.cpp" + case 634: +#line 762 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 638: /* select_limit_value: ALL */ -#line 766 "third_party/libpg_query/grammar/statements/select.y" - { - /* LIMIT ALL is represented as a NULL constant */ - (yyval.node) = makeNullAConst((yylsp[0])); - } -#line 24101 "third_party/libpg_query/grammar/grammar_out.cpp" + case 635: +#line 767 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = (yyvsp[(3) - (4)].ival); ;} break; - case 639: /* select_limit_value: a_expr '%' */ -#line 771 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeLimitPercent((yyvsp[-1].node)); } -#line 24107 "third_party/libpg_query/grammar/grammar_out.cpp" + case 636: +#line 768 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = -1; ;} break; - case 640: /* select_limit_value: FCONST PERCENT */ -#line 773 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeLimitPercent(makeFloatConst((yyvsp[-1].str),(yylsp[-1]))); } -#line 24113 "third_party/libpg_query/grammar/grammar_out.cpp" + case 637: +#line 772 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 641: /* select_limit_value: ICONST PERCENT */ -#line 775 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeLimitPercent(makeIntConst((yyvsp[-1].ival),(yylsp[-1]))); } -#line 24119 "third_party/libpg_query/grammar/grammar_out.cpp" + case 638: +#line 774 "third_party/libpg_query/grammar/statements/select.y" + { + /* LIMIT ALL is represented as a NULL constant */ + (yyval.node) = makeNullAConst((yylsp[(1) - (1)])); + ;} break; - case 642: /* select_offset_value: a_expr */ + case 639: #line 779 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24125 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeLimitPercent((yyvsp[(1) - (2)].node)); ;} break; - case 643: /* select_fetch_first_value: c_expr */ -#line 799 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24131 "third_party/libpg_query/grammar/grammar_out.cpp" + case 640: +#line 781 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = makeLimitPercent(makeFloatConst((yyvsp[(1) - (2)].str),(yylsp[(1) - (2)]))); ;} break; - case 644: /* select_fetch_first_value: '+' I_or_F_const */ -#line 801 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[0].node), (yylsp[-1])); } -#line 24137 "third_party/libpg_query/grammar/grammar_out.cpp" + case 641: +#line 783 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = makeLimitPercent(makeIntConst((yyvsp[(1) - (2)].ival),(yylsp[(1) - (2)]))); ;} break; - case 645: /* select_fetch_first_value: '-' I_or_F_const */ -#line 803 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = doNegate((yyvsp[0].node), (yylsp[-1])); } -#line 24143 "third_party/libpg_query/grammar/grammar_out.cpp" + case 642: +#line 787 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 646: /* I_or_F_const: Iconst */ + case 643: #line 807 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeIntConst((yyvsp[0].ival),(yylsp[0])); } -#line 24149 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 647: /* I_or_F_const: FCONST */ -#line 808 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeFloatConst((yyvsp[0].str),(yylsp[0])); } -#line 24155 "third_party/libpg_query/grammar/grammar_out.cpp" + case 644: +#line 809 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 648: /* row_or_rows: ROW */ -#line 812 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 24161 "third_party/libpg_query/grammar/grammar_out.cpp" + case 645: +#line 811 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 649: /* row_or_rows: ROWS */ -#line 813 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 24167 "third_party/libpg_query/grammar/grammar_out.cpp" + case 646: +#line 815 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival),(yylsp[(1) - (1)])); ;} break; - case 650: /* first_or_next: FIRST_P */ + case 647: #line 816 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 24173 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str),(yylsp[(1) - (1)])); ;} break; - case 651: /* first_or_next: NEXT */ -#line 817 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 24179 "third_party/libpg_query/grammar/grammar_out.cpp" + case 648: +#line 820 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = 0; ;} break; - case 652: /* group_clause: GROUP_P BY group_by_list_opt_comma */ -#line 842 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24185 "third_party/libpg_query/grammar/grammar_out.cpp" + case 649: +#line 821 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = 0; ;} break; - case 653: /* group_clause: GROUP_P BY ALL */ -#line 844 "third_party/libpg_query/grammar/statements/select.y" - { - PGNode *node = (PGNode *) makeGroupingSet(GROUPING_SET_ALL, NIL, (yylsp[0])); - (yyval.list) = list_make1(node); - } -#line 24194 "third_party/libpg_query/grammar/grammar_out.cpp" + case 650: +#line 824 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = 0; ;} break; - case 654: /* group_clause: %empty */ -#line 848 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24200 "third_party/libpg_query/grammar/grammar_out.cpp" + case 651: +#line 825 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = 0; ;} break; - case 655: /* group_by_list: group_by_item */ + case 652: +#line 850 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(3) - (3)].list); ;} + break; + + case 653: #line 852 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 24206 "third_party/libpg_query/grammar/grammar_out.cpp" + { + PGNode *node = (PGNode *) makeGroupingSet(GROUPING_SET_ALL, NIL, (yylsp[(3) - (3)])); + (yyval.list) = list_make1(node); + ;} break; - case 656: /* group_by_list: group_by_list ',' group_by_item */ -#line 853 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list),(yyvsp[0].node)); } -#line 24212 "third_party/libpg_query/grammar/grammar_out.cpp" + case 654: +#line 856 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 657: /* group_by_list_opt_comma: group_by_list */ -#line 857 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24218 "third_party/libpg_query/grammar/grammar_out.cpp" + case 655: +#line 860 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 658: /* group_by_list_opt_comma: group_by_list ',' */ -#line 858 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 24224 "third_party/libpg_query/grammar/grammar_out.cpp" + case 656: +#line 861 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].node)); ;} break; - case 659: /* group_by_item: a_expr */ -#line 862 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24230 "third_party/libpg_query/grammar/grammar_out.cpp" + case 657: +#line 865 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 660: /* group_by_item: empty_grouping_set */ -#line 863 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24236 "third_party/libpg_query/grammar/grammar_out.cpp" + case 658: +#line 866 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 661: /* group_by_item: cube_clause */ -#line 864 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24242 "third_party/libpg_query/grammar/grammar_out.cpp" + case 659: +#line 870 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 662: /* group_by_item: rollup_clause */ -#line 865 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24248 "third_party/libpg_query/grammar/grammar_out.cpp" + case 660: +#line 871 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 663: /* group_by_item: grouping_sets_clause */ -#line 866 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24254 "third_party/libpg_query/grammar/grammar_out.cpp" + case 661: +#line 872 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 664: /* empty_grouping_set: '(' ')' */ -#line 871 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_EMPTY, NIL, (yylsp[-1])); - } -#line 24262 "third_party/libpg_query/grammar/grammar_out.cpp" + case 662: +#line 873 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 665: /* rollup_clause: ROLLUP '(' expr_list_opt_comma ')' */ -#line 884 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_ROLLUP, (yyvsp[-1].list), (yylsp[-3])); - } -#line 24270 "third_party/libpg_query/grammar/grammar_out.cpp" + case 663: +#line 874 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 666: /* cube_clause: CUBE '(' expr_list_opt_comma ')' */ -#line 891 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_CUBE, (yyvsp[-1].list), (yylsp[-3])); - } -#line 24278 "third_party/libpg_query/grammar/grammar_out.cpp" + case 664: +#line 879 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_EMPTY, NIL, (yylsp[(1) - (2)])); + ;} break; - case 667: /* grouping_sets_clause: GROUPING SETS '(' group_by_list_opt_comma ')' */ -#line 898 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_SETS, (yyvsp[-1].list), (yylsp[-4])); - } -#line 24286 "third_party/libpg_query/grammar/grammar_out.cpp" + case 665: +#line 892 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_ROLLUP, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 668: /* grouping_or_grouping_id: GROUPING */ -#line 904 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24292 "third_party/libpg_query/grammar/grammar_out.cpp" + case 666: +#line 899 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_CUBE, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 669: /* grouping_or_grouping_id: GROUPING_ID */ -#line 905 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24298 "third_party/libpg_query/grammar/grammar_out.cpp" + case 667: +#line 906 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_SETS, (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); + ;} break; - case 670: /* having_clause: HAVING a_expr */ -#line 909 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24304 "third_party/libpg_query/grammar/grammar_out.cpp" + case 668: +#line 912 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 671: /* having_clause: %empty */ -#line 910 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24310 "third_party/libpg_query/grammar/grammar_out.cpp" + case 669: +#line 913 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 672: /* qualify_clause: QUALIFY a_expr */ -#line 914 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24316 "third_party/libpg_query/grammar/grammar_out.cpp" + case 670: +#line 917 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 673: /* qualify_clause: %empty */ -#line 915 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24322 "third_party/libpg_query/grammar/grammar_out.cpp" + case 671: +#line 918 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 674: /* for_locking_clause: for_locking_items */ -#line 919 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24328 "third_party/libpg_query/grammar/grammar_out.cpp" + case 672: +#line 922 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 675: /* for_locking_clause: FOR READ_P ONLY */ -#line 920 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24334 "third_party/libpg_query/grammar/grammar_out.cpp" + case 673: +#line 923 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 676: /* opt_for_locking_clause: for_locking_clause */ -#line 924 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24340 "third_party/libpg_query/grammar/grammar_out.cpp" + case 674: +#line 927 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 677: /* opt_for_locking_clause: %empty */ -#line 925 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24346 "third_party/libpg_query/grammar/grammar_out.cpp" + case 675: +#line 928 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 678: /* for_locking_items: for_locking_item */ -#line 929 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 24352 "third_party/libpg_query/grammar/grammar_out.cpp" + case 676: +#line 932 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 679: /* for_locking_items: for_locking_items for_locking_item */ -#line 930 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 24358 "third_party/libpg_query/grammar/grammar_out.cpp" + case 677: +#line 933 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 680: /* for_locking_item: for_locking_strength locked_rels_list opt_nowait_or_skip */ -#line 935 "third_party/libpg_query/grammar/statements/select.y" - { + case 678: +#line 937 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} + break; + + case 679: +#line 938 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} + break; + + case 680: +#line 943 "third_party/libpg_query/grammar/statements/select.y" + { PGLockingClause *n = makeNode(PGLockingClause); - n->lockedRels = (yyvsp[-1].list); - n->strength = (yyvsp[-2].lockstrength); - n->waitPolicy = (yyvsp[0].lockwaitpolicy); + n->lockedRels = (yyvsp[(2) - (3)].list); + n->strength = (yyvsp[(1) - (3)].lockstrength); + n->waitPolicy = (yyvsp[(3) - (3)].lockwaitpolicy); (yyval.node) = (PGNode *) n; - } -#line 24370 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 681: /* for_locking_strength: FOR UPDATE */ -#line 945 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockstrength) = LCS_FORUPDATE; } -#line 24376 "third_party/libpg_query/grammar/grammar_out.cpp" + case 681: +#line 953 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.lockstrength) = LCS_FORUPDATE; ;} break; - case 682: /* for_locking_strength: FOR NO KEY UPDATE */ -#line 946 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockstrength) = PG_LCS_FORNOKEYUPDATE; } -#line 24382 "third_party/libpg_query/grammar/grammar_out.cpp" + case 682: +#line 954 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.lockstrength) = PG_LCS_FORNOKEYUPDATE; ;} break; - case 683: /* for_locking_strength: FOR SHARE */ -#line 947 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockstrength) = PG_LCS_FORSHARE; } -#line 24388 "third_party/libpg_query/grammar/grammar_out.cpp" + case 683: +#line 955 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.lockstrength) = PG_LCS_FORSHARE; ;} break; - case 684: /* for_locking_strength: FOR KEY SHARE */ -#line 948 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockstrength) = PG_LCS_FORKEYSHARE; } -#line 24394 "third_party/libpg_query/grammar/grammar_out.cpp" + case 684: +#line 956 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.lockstrength) = PG_LCS_FORKEYSHARE; ;} break; - case 685: /* locked_rels_list: OF qualified_name_list */ -#line 952 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24400 "third_party/libpg_query/grammar/grammar_out.cpp" + case 685: +#line 960 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 686: /* locked_rels_list: %empty */ -#line 953 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24406 "third_party/libpg_query/grammar/grammar_out.cpp" + case 686: +#line 961 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 687: /* opt_nowait_or_skip: NOWAIT */ -#line 958 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockwaitpolicy) = LockWaitError; } -#line 24412 "third_party/libpg_query/grammar/grammar_out.cpp" + case 687: +#line 966 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.lockwaitpolicy) = LockWaitError; ;} break; - case 688: /* opt_nowait_or_skip: SKIP LOCKED */ -#line 959 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockwaitpolicy) = PGLockWaitSkip; } -#line 24418 "third_party/libpg_query/grammar/grammar_out.cpp" + case 688: +#line 967 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.lockwaitpolicy) = PGLockWaitSkip; ;} break; - case 689: /* opt_nowait_or_skip: %empty */ -#line 960 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockwaitpolicy) = PGLockWaitBlock; } -#line 24424 "third_party/libpg_query/grammar/grammar_out.cpp" + case 689: +#line 968 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.lockwaitpolicy) = PGLockWaitBlock; ;} break; - case 690: /* values_clause: VALUES '(' expr_list_opt_comma ')' */ -#line 970 "third_party/libpg_query/grammar/statements/select.y" - { + case 690: +#line 978 "third_party/libpg_query/grammar/statements/select.y" + { PGSelectStmt *n = makeNode(PGSelectStmt); - n->valuesLists = list_make1((yyvsp[-1].list)); + n->valuesLists = list_make1((yyvsp[(3) - (4)].list)); (yyval.node) = (PGNode *) n; - } -#line 24434 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 691: /* values_clause: values_clause ',' '(' expr_list_opt_comma ')' */ -#line 976 "third_party/libpg_query/grammar/statements/select.y" - { - PGSelectStmt *n = (PGSelectStmt *) (yyvsp[-4].node); - n->valuesLists = lappend(n->valuesLists, (yyvsp[-1].list)); + case 691: +#line 984 "third_party/libpg_query/grammar/statements/select.y" + { + PGSelectStmt *n = (PGSelectStmt *) (yyvsp[(1) - (5)].node); + n->valuesLists = lappend(n->valuesLists, (yyvsp[(4) - (5)].list)); (yyval.node) = (PGNode *) n; - } -#line 24444 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 692: /* values_clause_opt_comma: values_clause */ -#line 984 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24450 "third_party/libpg_query/grammar/grammar_out.cpp" + case 692: +#line 992 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 693: /* values_clause_opt_comma: values_clause ',' */ -#line 985 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 24456 "third_party/libpg_query/grammar/grammar_out.cpp" + case 693: +#line 993 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (2)].node); ;} break; - case 694: /* from_clause: FROM from_list_opt_comma */ -#line 998 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24462 "third_party/libpg_query/grammar/grammar_out.cpp" + case 694: +#line 1006 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 695: /* from_clause: %empty */ -#line 999 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24468 "third_party/libpg_query/grammar/grammar_out.cpp" + case 695: +#line 1007 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 696: /* from_list: table_ref */ -#line 1003 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 24474 "third_party/libpg_query/grammar/grammar_out.cpp" + case 696: +#line 1011 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 697: /* from_list: from_list ',' table_ref */ -#line 1004 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 24480 "third_party/libpg_query/grammar/grammar_out.cpp" + case 697: +#line 1012 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 698: /* from_list_opt_comma: from_list */ -#line 1008 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24486 "third_party/libpg_query/grammar/grammar_out.cpp" + case 698: +#line 1016 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 699: /* from_list_opt_comma: from_list ',' */ -#line 1009 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 24492 "third_party/libpg_query/grammar/grammar_out.cpp" + case 699: +#line 1017 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 700: /* table_ref: relation_expr opt_alias_clause opt_tablesample_clause */ -#line 1016 "third_party/libpg_query/grammar/statements/select.y" - { - (yyvsp[-2].range)->alias = (yyvsp[-1].alias); - (yyvsp[-2].range)->sample = (yyvsp[0].node); - (yyval.node) = (PGNode *) (yyvsp[-2].range); - } -#line 24502 "third_party/libpg_query/grammar/grammar_out.cpp" + case 700: +#line 1024 "third_party/libpg_query/grammar/statements/select.y" + { + (yyvsp[(1) - (3)].range)->alias = (yyvsp[(2) - (3)].alias); + (yyvsp[(1) - (3)].range)->sample = (yyvsp[(3) - (3)].node); + (yyval.node) = (PGNode *) (yyvsp[(1) - (3)].range); + ;} break; - case 701: /* table_ref: func_table func_alias_clause opt_tablesample_clause */ -#line 1022 "third_party/libpg_query/grammar/statements/select.y" - { - PGRangeFunction *n = (PGRangeFunction *) (yyvsp[-2].node); - n->alias = (PGAlias*) linitial((yyvsp[-1].list)); - n->coldeflist = (PGList*) lsecond((yyvsp[-1].list)); - n->sample = (yyvsp[0].node); + case 701: +#line 1030 "third_party/libpg_query/grammar/statements/select.y" + { + PGRangeFunction *n = (PGRangeFunction *) (yyvsp[(1) - (3)].node); + n->alias = (PGAlias*) linitial((yyvsp[(2) - (3)].list)); + n->coldeflist = (PGList*) lsecond((yyvsp[(2) - (3)].list)); + n->sample = (yyvsp[(3) - (3)].node); (yyval.node) = (PGNode *) n; - } -#line 24514 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 702: /* table_ref: values_clause_opt_comma alias_clause opt_tablesample_clause */ -#line 1030 "third_party/libpg_query/grammar/statements/select.y" - { + case 702: +#line 1038 "third_party/libpg_query/grammar/statements/select.y" + { PGRangeSubselect *n = makeNode(PGRangeSubselect); n->lateral = false; - n->subquery = (yyvsp[-2].node); - n->alias = (yyvsp[-1].alias); - n->sample = (yyvsp[0].node); + n->subquery = (yyvsp[(1) - (3)].node); + n->alias = (yyvsp[(2) - (3)].alias); + n->sample = (yyvsp[(3) - (3)].node); (yyval.node) = (PGNode *) n; - } -#line 24527 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 703: /* table_ref: LATERAL_P func_table func_alias_clause */ -#line 1039 "third_party/libpg_query/grammar/statements/select.y" - { - PGRangeFunction *n = (PGRangeFunction *) (yyvsp[-1].node); + case 703: +#line 1047 "third_party/libpg_query/grammar/statements/select.y" + { + PGRangeFunction *n = (PGRangeFunction *) (yyvsp[(2) - (3)].node); n->lateral = true; - n->alias = (PGAlias*) linitial((yyvsp[0].list)); - n->coldeflist = (PGList*) lsecond((yyvsp[0].list)); + n->alias = (PGAlias*) linitial((yyvsp[(3) - (3)].list)); + n->coldeflist = (PGList*) lsecond((yyvsp[(3) - (3)].list)); (yyval.node) = (PGNode *) n; - } -#line 24539 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 704: /* table_ref: select_with_parens opt_alias_clause opt_tablesample_clause */ -#line 1047 "third_party/libpg_query/grammar/statements/select.y" - { + case 704: +#line 1055 "third_party/libpg_query/grammar/statements/select.y" + { PGRangeSubselect *n = makeNode(PGRangeSubselect); n->lateral = false; - n->subquery = (yyvsp[-2].node); - n->alias = (yyvsp[-1].alias); - n->sample = (yyvsp[0].node); + n->subquery = (yyvsp[(1) - (3)].node); + n->alias = (yyvsp[(2) - (3)].alias); + n->sample = (yyvsp[(3) - (3)].node); (yyval.node) = (PGNode *) n; - } -#line 24552 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 705: /* table_ref: LATERAL_P select_with_parens opt_alias_clause */ -#line 1056 "third_party/libpg_query/grammar/statements/select.y" - { + case 705: +#line 1064 "third_party/libpg_query/grammar/statements/select.y" + { PGRangeSubselect *n = makeNode(PGRangeSubselect); n->lateral = true; - n->subquery = (yyvsp[-1].node); - n->alias = (yyvsp[0].alias); + n->subquery = (yyvsp[(2) - (3)].node); + n->alias = (yyvsp[(3) - (3)].alias); n->sample = NULL; (yyval.node) = (PGNode *) n; - } -#line 24565 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 706: /* table_ref: joined_table */ -#line 1065 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) (yyvsp[0].jexpr); - } -#line 24573 "third_party/libpg_query/grammar/grammar_out.cpp" + case 706: +#line 1073 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].jexpr); + ;} break; - case 707: /* table_ref: '(' joined_table ')' alias_clause */ -#line 1069 "third_party/libpg_query/grammar/statements/select.y" - { - (yyvsp[-2].jexpr)->alias = (yyvsp[0].alias); - (yyval.node) = (PGNode *) (yyvsp[-2].jexpr); - } -#line 24582 "third_party/libpg_query/grammar/grammar_out.cpp" + case 707: +#line 1077 "third_party/libpg_query/grammar/statements/select.y" + { + (yyvsp[(2) - (4)].jexpr)->alias = (yyvsp[(4) - (4)].alias); + (yyval.node) = (PGNode *) (yyvsp[(2) - (4)].jexpr); + ;} break; - case 708: /* table_ref: table_ref PIVOT '(' target_list_opt_comma FOR pivot_value_list opt_pivot_group_by ')' opt_alias_clause */ -#line 1074 "third_party/libpg_query/grammar/statements/select.y" - { + case 708: +#line 1082 "third_party/libpg_query/grammar/statements/select.y" + { PGPivotExpr *n = makeNode(PGPivotExpr); - n->source = (yyvsp[-8].node); - n->aggrs = (yyvsp[-5].list); - n->pivots = (yyvsp[-3].list); - n->groups = (yyvsp[-2].list); - n->alias = (yyvsp[0].alias); + n->source = (yyvsp[(1) - (9)].node); + n->aggrs = (yyvsp[(4) - (9)].list); + n->pivots = (yyvsp[(6) - (9)].list); + n->groups = (yyvsp[(7) - (9)].list); + n->alias = (yyvsp[(9) - (9)].alias); + n->location = (yylsp[(2) - (9)]); (yyval.node) = (PGNode *) n; - } -#line 24596 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 709: /* table_ref: table_ref UNPIVOT opt_include_nulls '(' unpivot_header FOR unpivot_value_list ')' opt_alias_clause */ -#line 1084 "third_party/libpg_query/grammar/statements/select.y" - { + case 709: +#line 1093 "third_party/libpg_query/grammar/statements/select.y" + { PGPivotExpr *n = makeNode(PGPivotExpr); - n->source = (yyvsp[-8].node); - n->include_nulls = (yyvsp[-6].boolean); - n->unpivots = (yyvsp[-4].list); - n->pivots = (yyvsp[-2].list); - n->alias = (yyvsp[0].alias); + n->source = (yyvsp[(1) - (9)].node); + n->include_nulls = (yyvsp[(3) - (9)].boolean); + n->unpivots = (yyvsp[(5) - (9)].list); + n->pivots = (yyvsp[(7) - (9)].list); + n->alias = (yyvsp[(9) - (9)].alias); + n->location = (yylsp[(2) - (9)]); (yyval.node) = (PGNode *) n; - } -#line 24610 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 710: /* opt_pivot_group_by: GROUP_P BY name_list_opt_comma */ -#line 1096 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24616 "third_party/libpg_query/grammar/grammar_out.cpp" + case 710: +#line 1106 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 711: /* opt_pivot_group_by: %empty */ -#line 1097 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NULL; } -#line 24622 "third_party/libpg_query/grammar/grammar_out.cpp" + case 711: +#line 1107 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NULL; ;} break; - case 712: /* opt_include_nulls: INCLUDE_P NULLS_P */ -#line 1100 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 24628 "third_party/libpg_query/grammar/grammar_out.cpp" + case 712: +#line 1110 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = true; ;} break; - case 713: /* opt_include_nulls: EXCLUDE NULLS_P */ -#line 1101 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 24634 "third_party/libpg_query/grammar/grammar_out.cpp" + case 713: +#line 1111 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = false; ;} break; - case 714: /* opt_include_nulls: %empty */ -#line 1102 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 24640 "third_party/libpg_query/grammar/grammar_out.cpp" + case 714: +#line 1112 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = false; ;} break; - case 715: /* single_pivot_value: b_expr IN_P '(' target_list_opt_comma ')' */ -#line 1106 "third_party/libpg_query/grammar/statements/select.y" - { + case 715: +#line 1116 "third_party/libpg_query/grammar/statements/select.y" + { PGPivot *n = makeNode(PGPivot); - n->pivot_columns = list_make1((yyvsp[-4].node)); - n->pivot_value = (yyvsp[-1].list); + n->pivot_columns = list_make1((yyvsp[(1) - (5)].node)); + n->pivot_value = (yyvsp[(4) - (5)].list); (yyval.node) = (PGNode *) n; - } -#line 24651 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 716: /* single_pivot_value: b_expr IN_P ColIdOrString */ -#line 1114 "third_party/libpg_query/grammar/statements/select.y" - { + case 716: +#line 1124 "third_party/libpg_query/grammar/statements/select.y" + { PGPivot *n = makeNode(PGPivot); - n->pivot_columns = list_make1((yyvsp[-2].node)); - n->pivot_enum = (yyvsp[0].str); + n->pivot_columns = list_make1((yyvsp[(1) - (3)].node)); + n->pivot_enum = (yyvsp[(3) - (3)].str); (yyval.node) = (PGNode *) n; - } -#line 24662 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 717: /* pivot_header: d_expr */ -#line 1123 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 24668 "third_party/libpg_query/grammar/grammar_out.cpp" + case 718: +#line 1133 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 718: /* pivot_header: '(' c_expr_list_opt_comma ')' */ -#line 1124 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 24674 "third_party/libpg_query/grammar/grammar_out.cpp" + case 719: +#line 1134 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 719: /* pivot_value: pivot_header IN_P '(' target_list_opt_comma ')' */ -#line 1128 "third_party/libpg_query/grammar/statements/select.y" - { + case 720: +#line 1135 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} + break; + + case 721: +#line 1139 "third_party/libpg_query/grammar/statements/select.y" + { PGPivot *n = makeNode(PGPivot); - n->pivot_columns = (yyvsp[-4].list); - n->pivot_value = (yyvsp[-1].list); + n->pivot_columns = (yyvsp[(1) - (5)].list); + n->pivot_value = (yyvsp[(4) - (5)].list); (yyval.node) = (PGNode *) n; - } -#line 24685 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 720: /* pivot_value: pivot_header IN_P ColIdOrString */ -#line 1136 "third_party/libpg_query/grammar/statements/select.y" - { + case 722: +#line 1147 "third_party/libpg_query/grammar/statements/select.y" + { PGPivot *n = makeNode(PGPivot); - n->pivot_columns = (yyvsp[-2].list); - n->pivot_enum = (yyvsp[0].str); + n->pivot_columns = (yyvsp[(1) - (3)].list); + n->pivot_enum = (yyvsp[(3) - (3)].str); (yyval.node) = (PGNode *) n; - } -#line 24696 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 721: /* pivot_value_list: pivot_value */ -#line 1145 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 24704 "third_party/libpg_query/grammar/grammar_out.cpp" + case 723: +#line 1156 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 722: /* pivot_value_list: pivot_value_list pivot_value */ -#line 1149 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); - } -#line 24712 "third_party/libpg_query/grammar/grammar_out.cpp" + case 724: +#line 1160 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); + ;} break; - case 723: /* unpivot_header: ColIdOrString */ -#line 1155 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 24718 "third_party/libpg_query/grammar/grammar_out.cpp" + case 725: +#line 1166 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 724: /* unpivot_header: '(' name_list_opt_comma ')' */ -#line 1156 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 24724 "third_party/libpg_query/grammar/grammar_out.cpp" + case 726: +#line 1167 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 725: /* unpivot_value: unpivot_header IN_P '(' target_list_opt_comma ')' */ -#line 1161 "third_party/libpg_query/grammar/statements/select.y" - { + case 727: +#line 1172 "third_party/libpg_query/grammar/statements/select.y" + { PGPivot *n = makeNode(PGPivot); - n->unpivot_columns = (yyvsp[-4].list); - n->pivot_value = (yyvsp[-1].list); + n->unpivot_columns = (yyvsp[(1) - (5)].list); + n->pivot_value = (yyvsp[(4) - (5)].list); (yyval.node) = (PGNode *) n; - } -#line 24735 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 726: /* unpivot_value_list: unpivot_value */ -#line 1170 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 24743 "third_party/libpg_query/grammar/grammar_out.cpp" + case 728: +#line 1181 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 727: /* unpivot_value_list: unpivot_value_list unpivot_value */ -#line 1174 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); - } -#line 24751 "third_party/libpg_query/grammar/grammar_out.cpp" + case 729: +#line 1185 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); + ;} break; - case 728: /* joined_table: '(' joined_table ')' */ -#line 1199 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.jexpr) = (yyvsp[-1].jexpr); - } -#line 24759 "third_party/libpg_query/grammar/grammar_out.cpp" + case 730: +#line 1210 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.jexpr) = (yyvsp[(2) - (3)].jexpr); + ;} break; - case 729: /* joined_table: table_ref CROSS JOIN table_ref */ -#line 1203 "third_party/libpg_query/grammar/statements/select.y" - { + case 731: +#line 1214 "third_party/libpg_query/grammar/statements/select.y" + { /* CROSS JOIN is same as unqualified inner join */ PGJoinExpr *n = makeNode(PGJoinExpr); n->jointype = PG_JOIN_INNER; n->joinreftype = PG_JOIN_REGULAR; - n->larg = (yyvsp[-3].node); - n->rarg = (yyvsp[0].node); + n->larg = (yyvsp[(1) - (4)].node); + n->rarg = (yyvsp[(4) - (4)].node); n->usingClause = NIL; n->quals = NULL; - n->location = (yylsp[-2]); + n->location = (yylsp[(2) - (4)]); (yyval.jexpr) = n; - } -#line 24776 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 730: /* joined_table: table_ref join_type JOIN table_ref join_qual */ -#line 1216 "third_party/libpg_query/grammar/statements/select.y" - { + case 732: +#line 1227 "third_party/libpg_query/grammar/statements/select.y" + { PGJoinExpr *n = makeNode(PGJoinExpr); - n->jointype = (yyvsp[-3].jtype); + n->jointype = (yyvsp[(2) - (5)].jtype); n->joinreftype = PG_JOIN_REGULAR; - n->larg = (yyvsp[-4].node); - n->rarg = (yyvsp[-1].node); - if ((yyvsp[0].node) != NULL && IsA((yyvsp[0].node), PGList)) - n->usingClause = (PGList *) (yyvsp[0].node); /* USING clause */ + n->larg = (yyvsp[(1) - (5)].node); + n->rarg = (yyvsp[(4) - (5)].node); + if ((yyvsp[(5) - (5)].node) != NULL && IsA((yyvsp[(5) - (5)].node), PGList)) + n->usingClause = (PGList *) (yyvsp[(5) - (5)].node); /* USING clause */ else - n->quals = (yyvsp[0].node); /* ON clause */ - n->location = (yylsp[-3]); + n->quals = (yyvsp[(5) - (5)].node); /* ON clause */ + n->location = (yylsp[(2) - (5)]); (yyval.jexpr) = n; - } -#line 24794 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 731: /* joined_table: table_ref JOIN table_ref join_qual */ -#line 1230 "third_party/libpg_query/grammar/statements/select.y" - { + case 733: +#line 1241 "third_party/libpg_query/grammar/statements/select.y" + { /* letting join_type reduce to empty doesn't work */ PGJoinExpr *n = makeNode(PGJoinExpr); n->jointype = PG_JOIN_INNER; n->joinreftype = PG_JOIN_REGULAR; - n->larg = (yyvsp[-3].node); - n->rarg = (yyvsp[-1].node); - if ((yyvsp[0].node) != NULL && IsA((yyvsp[0].node), PGList)) - n->usingClause = (PGList *) (yyvsp[0].node); /* USING clause */ + n->larg = (yyvsp[(1) - (4)].node); + n->rarg = (yyvsp[(3) - (4)].node); + if ((yyvsp[(4) - (4)].node) != NULL && IsA((yyvsp[(4) - (4)].node), PGList)) + n->usingClause = (PGList *) (yyvsp[(4) - (4)].node); /* USING clause */ else - n->quals = (yyvsp[0].node); /* ON clause */ - n->location = (yylsp[-2]); + n->quals = (yyvsp[(4) - (4)].node); /* ON clause */ + n->location = (yylsp[(2) - (4)]); (yyval.jexpr) = n; - } -#line 24813 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 732: /* joined_table: table_ref NATURAL join_type JOIN table_ref */ -#line 1245 "third_party/libpg_query/grammar/statements/select.y" - { + case 734: +#line 1256 "third_party/libpg_query/grammar/statements/select.y" + { PGJoinExpr *n = makeNode(PGJoinExpr); - n->jointype = (yyvsp[-2].jtype); + n->jointype = (yyvsp[(3) - (5)].jtype); n->joinreftype = PG_JOIN_NATURAL; - n->larg = (yyvsp[-4].node); - n->rarg = (yyvsp[0].node); + n->larg = (yyvsp[(1) - (5)].node); + n->rarg = (yyvsp[(5) - (5)].node); n->usingClause = NIL; /* figure out which columns later... */ n->quals = NULL; /* fill later */ - n->location = (yylsp[-3]); + n->location = (yylsp[(2) - (5)]); (yyval.jexpr) = n; - } -#line 24829 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 733: /* joined_table: table_ref NATURAL JOIN table_ref */ -#line 1257 "third_party/libpg_query/grammar/statements/select.y" - { + case 735: +#line 1268 "third_party/libpg_query/grammar/statements/select.y" + { /* letting join_type reduce to empty doesn't work */ PGJoinExpr *n = makeNode(PGJoinExpr); n->jointype = PG_JOIN_INNER; n->joinreftype = PG_JOIN_NATURAL; - n->larg = (yyvsp[-3].node); - n->rarg = (yyvsp[0].node); + n->larg = (yyvsp[(1) - (4)].node); + n->rarg = (yyvsp[(4) - (4)].node); n->usingClause = NIL; /* figure out which columns later... */ n->quals = NULL; /* fill later */ - n->location = (yylsp[-2]); + n->location = (yylsp[(2) - (4)]); (yyval.jexpr) = n; - } -#line 24846 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 734: /* joined_table: table_ref ASOF join_type JOIN table_ref join_qual */ -#line 1270 "third_party/libpg_query/grammar/statements/select.y" - { + case 736: +#line 1281 "third_party/libpg_query/grammar/statements/select.y" + { PGJoinExpr *n = makeNode(PGJoinExpr); - n->jointype = (yyvsp[-3].jtype); + n->jointype = (yyvsp[(3) - (6)].jtype); n->joinreftype = PG_JOIN_ASOF; - n->larg = (yyvsp[-5].node); - n->rarg = (yyvsp[-1].node); - if ((yyvsp[0].node) != NULL && IsA((yyvsp[0].node), PGList)) - n->usingClause = (PGList *) (yyvsp[0].node); /* USING clause */ + n->larg = (yyvsp[(1) - (6)].node); + n->rarg = (yyvsp[(5) - (6)].node); + if ((yyvsp[(6) - (6)].node) != NULL && IsA((yyvsp[(6) - (6)].node), PGList)) + n->usingClause = (PGList *) (yyvsp[(6) - (6)].node); /* USING clause */ else - n->quals = (yyvsp[0].node); /* ON clause */ - n->location = (yylsp[-4]); + n->quals = (yyvsp[(6) - (6)].node); /* ON clause */ + n->location = (yylsp[(2) - (6)]); (yyval.jexpr) = n; - } -#line 24864 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 735: /* joined_table: table_ref ASOF JOIN table_ref join_qual */ -#line 1284 "third_party/libpg_query/grammar/statements/select.y" - { + case 737: +#line 1295 "third_party/libpg_query/grammar/statements/select.y" + { PGJoinExpr *n = makeNode(PGJoinExpr); n->jointype = PG_JOIN_INNER; n->joinreftype = PG_JOIN_ASOF; - n->larg = (yyvsp[-4].node); - n->rarg = (yyvsp[-1].node); - if ((yyvsp[0].node) != NULL && IsA((yyvsp[0].node), PGList)) - n->usingClause = (PGList *) (yyvsp[0].node); /* USING clause */ + n->larg = (yyvsp[(1) - (5)].node); + n->rarg = (yyvsp[(4) - (5)].node); + if ((yyvsp[(5) - (5)].node) != NULL && IsA((yyvsp[(5) - (5)].node), PGList)) + n->usingClause = (PGList *) (yyvsp[(5) - (5)].node); /* USING clause */ else - n->quals = (yyvsp[0].node); /* ON clause */ - n->location = (yylsp[-3]); + n->quals = (yyvsp[(5) - (5)].node); /* ON clause */ + n->location = (yylsp[(2) - (5)]); (yyval.jexpr) = n; - } -#line 24882 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 736: /* joined_table: table_ref POSITIONAL JOIN table_ref */ -#line 1298 "third_party/libpg_query/grammar/statements/select.y" - { + case 738: +#line 1309 "third_party/libpg_query/grammar/statements/select.y" + { /* POSITIONAL JOIN is a coordinated scan */ PGJoinExpr *n = makeNode(PGJoinExpr); n->jointype = PG_JOIN_POSITION; n->joinreftype = PG_JOIN_REGULAR; - n->larg = (yyvsp[-3].node); - n->rarg = (yyvsp[0].node); + n->larg = (yyvsp[(1) - (4)].node); + n->rarg = (yyvsp[(4) - (4)].node); n->usingClause = NIL; n->quals = NULL; - n->location = (yylsp[-2]); + n->location = (yylsp[(2) - (4)]); (yyval.jexpr) = n; - } -#line 24899 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 737: /* joined_table: table_ref ANTI JOIN table_ref join_qual */ -#line 1311 "third_party/libpg_query/grammar/statements/select.y" - { + case 739: +#line 1322 "third_party/libpg_query/grammar/statements/select.y" + { /* ANTI JOIN is a filter */ PGJoinExpr *n = makeNode(PGJoinExpr); n->jointype = PG_JOIN_ANTI; n->joinreftype = PG_JOIN_REGULAR; - n->larg = (yyvsp[-4].node); - n->rarg = (yyvsp[-1].node); - if ((yyvsp[0].node) != NULL && IsA((yyvsp[0].node), PGList)) - n->usingClause = (PGList *) (yyvsp[0].node); /* USING clause */ + n->larg = (yyvsp[(1) - (5)].node); + n->rarg = (yyvsp[(4) - (5)].node); + if ((yyvsp[(5) - (5)].node) != NULL && IsA((yyvsp[(5) - (5)].node), PGList)) + n->usingClause = (PGList *) (yyvsp[(5) - (5)].node); /* USING clause */ else - n->quals = (yyvsp[0].node); /* ON clause */ - n->location = (yylsp[-3]); + n->quals = (yyvsp[(5) - (5)].node); /* ON clause */ + n->location = (yylsp[(2) - (5)]); (yyval.jexpr) = n; - } -#line 24918 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 738: /* joined_table: table_ref SEMI JOIN table_ref join_qual */ -#line 1326 "third_party/libpg_query/grammar/statements/select.y" - { + case 740: +#line 1337 "third_party/libpg_query/grammar/statements/select.y" + { /* SEMI JOIN is also a filter */ PGJoinExpr *n = makeNode(PGJoinExpr); n->jointype = PG_JOIN_SEMI; n->joinreftype = PG_JOIN_REGULAR; - n->larg = (yyvsp[-4].node); - n->rarg = (yyvsp[-1].node); - if ((yyvsp[0].node) != NULL && IsA((yyvsp[0].node), PGList)) - n->usingClause = (PGList *) (yyvsp[0].node); /* USING clause */ + n->larg = (yyvsp[(1) - (5)].node); + n->rarg = (yyvsp[(4) - (5)].node); + if ((yyvsp[(5) - (5)].node) != NULL && IsA((yyvsp[(5) - (5)].node), PGList)) + n->usingClause = (PGList *) (yyvsp[(5) - (5)].node); /* USING clause */ else - n->quals = (yyvsp[0].node); /* ON clause */ - n->location = (yylsp[-3]); - n->location = (yylsp[-3]); + n->quals = (yyvsp[(5) - (5)].node); /* ON clause */ + n->location = (yylsp[(2) - (5)]); + n->location = (yylsp[(2) - (5)]); (yyval.jexpr) = n; - } -#line 24938 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 739: /* alias_clause: AS ColIdOrString '(' name_list_opt_comma ')' */ -#line 1345 "third_party/libpg_query/grammar/statements/select.y" - { + case 741: +#line 1356 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.alias) = makeNode(PGAlias); - (yyval.alias)->aliasname = (yyvsp[-3].str); - (yyval.alias)->colnames = (yyvsp[-1].list); - } -#line 24948 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.alias)->aliasname = (yyvsp[(2) - (5)].str); + (yyval.alias)->colnames = (yyvsp[(4) - (5)].list); + ;} break; - case 740: /* alias_clause: AS ColIdOrString */ -#line 1351 "third_party/libpg_query/grammar/statements/select.y" - { + case 742: +#line 1362 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.alias) = makeNode(PGAlias); - (yyval.alias)->aliasname = (yyvsp[0].str); - } -#line 24957 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.alias)->aliasname = (yyvsp[(2) - (2)].str); + ;} break; - case 741: /* alias_clause: ColId '(' name_list_opt_comma ')' */ -#line 1356 "third_party/libpg_query/grammar/statements/select.y" - { + case 743: +#line 1367 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.alias) = makeNode(PGAlias); - (yyval.alias)->aliasname = (yyvsp[-3].str); - (yyval.alias)->colnames = (yyvsp[-1].list); - } -#line 24967 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.alias)->aliasname = (yyvsp[(1) - (4)].str); + (yyval.alias)->colnames = (yyvsp[(3) - (4)].list); + ;} break; - case 742: /* alias_clause: ColId */ -#line 1362 "third_party/libpg_query/grammar/statements/select.y" - { + case 744: +#line 1373 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.alias) = makeNode(PGAlias); - (yyval.alias)->aliasname = (yyvsp[0].str); - } -#line 24976 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.alias)->aliasname = (yyvsp[(1) - (1)].str); + ;} break; - case 743: /* opt_alias_clause: alias_clause */ -#line 1368 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.alias) = (yyvsp[0].alias); } -#line 24982 "third_party/libpg_query/grammar/grammar_out.cpp" + case 745: +#line 1379 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.alias) = (yyvsp[(1) - (1)].alias); ;} break; - case 744: /* opt_alias_clause: %empty */ -#line 1369 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.alias) = NULL; } -#line 24988 "third_party/libpg_query/grammar/grammar_out.cpp" + case 746: +#line 1380 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.alias) = NULL; ;} break; - case 745: /* func_alias_clause: alias_clause */ -#line 1378 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make2((yyvsp[0].alias), NIL); - } -#line 24996 "third_party/libpg_query/grammar/grammar_out.cpp" + case 747: +#line 1389 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = list_make2((yyvsp[(1) - (1)].alias), NIL); + ;} break; - case 746: /* func_alias_clause: AS '(' TableFuncElementList ')' */ -#line 1382 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make2(NULL, (yyvsp[-1].list)); - } -#line 25004 "third_party/libpg_query/grammar/grammar_out.cpp" + case 748: +#line 1393 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = list_make2(NULL, (yyvsp[(3) - (4)].list)); + ;} break; - case 747: /* func_alias_clause: AS ColIdOrString '(' TableFuncElementList ')' */ -#line 1386 "third_party/libpg_query/grammar/statements/select.y" - { + case 749: +#line 1397 "third_party/libpg_query/grammar/statements/select.y" + { PGAlias *a = makeNode(PGAlias); - a->aliasname = (yyvsp[-3].str); - (yyval.list) = list_make2(a, (yyvsp[-1].list)); - } -#line 25014 "third_party/libpg_query/grammar/grammar_out.cpp" + a->aliasname = (yyvsp[(2) - (5)].str); + (yyval.list) = list_make2(a, (yyvsp[(4) - (5)].list)); + ;} break; - case 748: /* func_alias_clause: ColId '(' TableFuncElementList ')' */ -#line 1392 "third_party/libpg_query/grammar/statements/select.y" - { + case 750: +#line 1403 "third_party/libpg_query/grammar/statements/select.y" + { PGAlias *a = makeNode(PGAlias); - a->aliasname = (yyvsp[-3].str); - (yyval.list) = list_make2(a, (yyvsp[-1].list)); - } -#line 25024 "third_party/libpg_query/grammar/grammar_out.cpp" + a->aliasname = (yyvsp[(1) - (4)].str); + (yyval.list) = list_make2(a, (yyvsp[(3) - (4)].list)); + ;} break; - case 749: /* func_alias_clause: %empty */ -#line 1398 "third_party/libpg_query/grammar/statements/select.y" - { + case 751: +#line 1409 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make2(NULL, NIL); - } -#line 25032 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 750: /* join_type: FULL join_outer */ -#line 1403 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_FULL; } -#line 25038 "third_party/libpg_query/grammar/grammar_out.cpp" + case 752: +#line 1414 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.jtype) = PG_JOIN_FULL; ;} break; - case 751: /* join_type: LEFT join_outer */ -#line 1404 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_LEFT; } -#line 25044 "third_party/libpg_query/grammar/grammar_out.cpp" + case 753: +#line 1415 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.jtype) = PG_JOIN_LEFT; ;} break; - case 752: /* join_type: RIGHT join_outer */ -#line 1405 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_RIGHT; } -#line 25050 "third_party/libpg_query/grammar/grammar_out.cpp" + case 754: +#line 1416 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.jtype) = PG_JOIN_RIGHT; ;} break; - case 753: /* join_type: SEMI */ -#line 1406 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_SEMI; } -#line 25056 "third_party/libpg_query/grammar/grammar_out.cpp" + case 755: +#line 1417 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.jtype) = PG_JOIN_SEMI; ;} break; - case 754: /* join_type: ANTI */ -#line 1407 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_ANTI; } -#line 25062 "third_party/libpg_query/grammar/grammar_out.cpp" + case 756: +#line 1418 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.jtype) = PG_JOIN_ANTI; ;} break; - case 755: /* join_type: INNER_P */ -#line 1408 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_INNER; } -#line 25068 "third_party/libpg_query/grammar/grammar_out.cpp" + case 757: +#line 1419 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.jtype) = PG_JOIN_INNER; ;} break; - case 756: /* join_outer: OUTER_P */ -#line 1412 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 25074 "third_party/libpg_query/grammar/grammar_out.cpp" + case 758: +#line 1423 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 757: /* join_outer: %empty */ -#line 1413 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 25080 "third_party/libpg_query/grammar/grammar_out.cpp" + case 759: +#line 1424 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 758: /* join_qual: USING '(' name_list_opt_comma ')' */ -#line 1425 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) (yyvsp[-1].list); } -#line 25086 "third_party/libpg_query/grammar/grammar_out.cpp" + case 760: +#line 1436 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) (yyvsp[(3) - (4)].list); ;} break; - case 759: /* join_qual: ON a_expr */ -#line 1426 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 25092 "third_party/libpg_query/grammar/grammar_out.cpp" + case 761: +#line 1437 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 760: /* relation_expr: qualified_name */ -#line 1432 "third_party/libpg_query/grammar/statements/select.y" - { + case 762: +#line 1443 "third_party/libpg_query/grammar/statements/select.y" + { /* inheritance query, implicitly */ - (yyval.range) = (yyvsp[0].range); + (yyval.range) = (yyvsp[(1) - (1)].range); (yyval.range)->inh = true; (yyval.range)->alias = NULL; - } -#line 25103 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 761: /* relation_expr: qualified_name '*' */ -#line 1439 "third_party/libpg_query/grammar/statements/select.y" - { + case 763: +#line 1450 "third_party/libpg_query/grammar/statements/select.y" + { /* inheritance query, explicitly */ - (yyval.range) = (yyvsp[-1].range); + (yyval.range) = (yyvsp[(1) - (2)].range); (yyval.range)->inh = true; (yyval.range)->alias = NULL; - } -#line 25114 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 762: /* relation_expr: ONLY qualified_name */ -#line 1446 "third_party/libpg_query/grammar/statements/select.y" - { + case 764: +#line 1457 "third_party/libpg_query/grammar/statements/select.y" + { /* no inheritance */ - (yyval.range) = (yyvsp[0].range); + (yyval.range) = (yyvsp[(2) - (2)].range); (yyval.range)->inh = false; (yyval.range)->alias = NULL; - } -#line 25125 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 763: /* relation_expr: ONLY '(' qualified_name ')' */ -#line 1453 "third_party/libpg_query/grammar/statements/select.y" - { + case 765: +#line 1464 "third_party/libpg_query/grammar/statements/select.y" + { /* no inheritance, SQL99-style syntax */ - (yyval.range) = (yyvsp[-1].range); + (yyval.range) = (yyvsp[(3) - (4)].range); (yyval.range)->inh = false; (yyval.range)->alias = NULL; - } -#line 25136 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 764: /* func_table: func_expr_windowless opt_ordinality */ -#line 1485 "third_party/libpg_query/grammar/statements/select.y" - { + case 766: +#line 1496 "third_party/libpg_query/grammar/statements/select.y" + { PGRangeFunction *n = makeNode(PGRangeFunction); n->lateral = false; - n->ordinality = (yyvsp[0].boolean); + n->ordinality = (yyvsp[(2) - (2)].boolean); n->is_rowsfrom = false; - n->functions = list_make1(list_make2((yyvsp[-1].node), NIL)); + n->functions = list_make1(list_make2((yyvsp[(1) - (2)].node), NIL)); n->sample = NULL; /* alias and coldeflist are set by table_ref production */ (yyval.node) = (PGNode *) n; - } -#line 25151 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 765: /* func_table: ROWS FROM '(' rowsfrom_list ')' opt_ordinality */ -#line 1496 "third_party/libpg_query/grammar/statements/select.y" - { + case 767: +#line 1507 "third_party/libpg_query/grammar/statements/select.y" + { PGRangeFunction *n = makeNode(PGRangeFunction); n->lateral = false; - n->ordinality = (yyvsp[0].boolean); + n->ordinality = (yyvsp[(6) - (6)].boolean); n->is_rowsfrom = true; - n->functions = (yyvsp[-2].list); + n->functions = (yyvsp[(4) - (6)].list); n->sample = NULL; /* alias and coldeflist are set by table_ref production */ (yyval.node) = (PGNode *) n; - } -#line 25166 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 766: /* rowsfrom_item: func_expr_windowless opt_col_def_list */ -#line 1509 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[-1].node), (yyvsp[0].list)); } -#line 25172 "third_party/libpg_query/grammar/grammar_out.cpp" + case 768: +#line 1520 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].list)); ;} break; - case 767: /* rowsfrom_list: rowsfrom_item */ -#line 1513 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].list)); } -#line 25178 "third_party/libpg_query/grammar/grammar_out.cpp" + case 769: +#line 1524 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 768: /* rowsfrom_list: rowsfrom_list ',' rowsfrom_item */ -#line 1514 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].list)); } -#line 25184 "third_party/libpg_query/grammar/grammar_out.cpp" + case 770: +#line 1525 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 769: /* opt_col_def_list: AS '(' TableFuncElementList ')' */ -#line 1517 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 25190 "third_party/libpg_query/grammar/grammar_out.cpp" + case 771: +#line 1528 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 770: /* opt_col_def_list: %empty */ -#line 1518 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 25196 "third_party/libpg_query/grammar/grammar_out.cpp" + case 772: +#line 1529 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 771: /* opt_ordinality: WITH_LA ORDINALITY */ -#line 1521 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 25202 "third_party/libpg_query/grammar/grammar_out.cpp" + case 773: +#line 1532 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = true; ;} break; - case 772: /* opt_ordinality: %empty */ -#line 1522 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 25208 "third_party/libpg_query/grammar/grammar_out.cpp" + case 774: +#line 1533 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = false; ;} break; - case 773: /* where_clause: WHERE a_expr */ -#line 1527 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 25214 "third_party/libpg_query/grammar/grammar_out.cpp" + case 775: +#line 1538 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 774: /* where_clause: %empty */ -#line 1528 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 25220 "third_party/libpg_query/grammar/grammar_out.cpp" + case 776: +#line 1539 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 775: /* TableFuncElementList: TableFuncElement */ -#line 1534 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 25228 "third_party/libpg_query/grammar/grammar_out.cpp" + case 777: +#line 1545 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 776: /* TableFuncElementList: TableFuncElementList ',' TableFuncElement */ -#line 1538 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 25236 "third_party/libpg_query/grammar/grammar_out.cpp" + case 778: +#line 1549 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 777: /* TableFuncElement: ColIdOrString Typename opt_collate_clause */ -#line 1544 "third_party/libpg_query/grammar/statements/select.y" - { + case 779: +#line 1555 "third_party/libpg_query/grammar/statements/select.y" + { PGColumnDef *n = makeNode(PGColumnDef); - n->colname = (yyvsp[-2].str); - n->typeName = (yyvsp[-1].typnam); + n->colname = (yyvsp[(1) - (3)].str); + n->typeName = (yyvsp[(2) - (3)].typnam); n->inhcount = 0; n->is_local = true; n->is_not_null = false; @@ -411764,470 +415612,416 @@ YYLTYPE yylloc = yyloc_default; n->storage = 0; n->raw_default = NULL; n->cooked_default = NULL; - n->collClause = (PGCollateClause *) (yyvsp[0].node); + n->collClause = (PGCollateClause *) (yyvsp[(3) - (3)].node); n->collOid = InvalidOid; n->constraints = NIL; - n->location = (yylsp[-2]); + n->location = (yylsp[(1) - (3)]); (yyval.node) = (PGNode *)n; - } -#line 25258 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 778: /* opt_collate_clause: COLLATE any_name */ -#line 1565 "third_party/libpg_query/grammar/statements/select.y" - { + case 780: +#line 1576 "third_party/libpg_query/grammar/statements/select.y" + { PGCollateClause *n = makeNode(PGCollateClause); n->arg = NULL; - n->collname = (yyvsp[0].list); - n->location = (yylsp[-1]); + n->collname = (yyvsp[(2) - (2)].list); + n->location = (yylsp[(1) - (2)]); (yyval.node) = (PGNode *) n; - } -#line 25270 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 779: /* opt_collate_clause: %empty */ -#line 1572 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 25276 "third_party/libpg_query/grammar/grammar_out.cpp" + case 781: +#line 1583 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 780: /* colid_type_list: ColId Typename */ -#line 1585 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1(list_make2(makeString((yyvsp[-1].str)), (yyvsp[0].typnam))); - } -#line 25284 "third_party/libpg_query/grammar/grammar_out.cpp" + case 782: +#line 1596 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = list_make1(list_make2(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].typnam))); + ;} break; - case 781: /* colid_type_list: colid_type_list ',' ColId Typename */ -#line 1588 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-3].list), list_make2(makeString((yyvsp[-1].str)), (yyvsp[0].typnam))); - } -#line 25292 "third_party/libpg_query/grammar/grammar_out.cpp" + case 783: +#line 1599 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = lappend((yyvsp[(1) - (4)].list), list_make2(makeString((yyvsp[(3) - (4)].str)), (yyvsp[(4) - (4)].typnam))); + ;} break; - case 784: /* opt_Typename: Typename */ -#line 1595 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25298 "third_party/libpg_query/grammar/grammar_out.cpp" + case 786: +#line 1606 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 785: /* opt_Typename: %empty */ -#line 1596 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = NULL; } -#line 25304 "third_party/libpg_query/grammar/grammar_out.cpp" + case 787: +#line 1607 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = NULL; ;} break; - case 786: /* Typename: SimpleTypename opt_array_bounds */ -#line 1599 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-1].typnam); - (yyval.typnam)->arrayBounds = (yyvsp[0].list); - } -#line 25313 "third_party/libpg_query/grammar/grammar_out.cpp" + case 788: +#line 1610 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (2)].typnam); + (yyval.typnam)->arrayBounds = (yyvsp[(2) - (2)].list); + ;} break; - case 787: /* Typename: SETOF SimpleTypename opt_array_bounds */ -#line 1604 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-1].typnam); - (yyval.typnam)->arrayBounds = (yyvsp[0].list); + case 789: +#line 1615 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(2) - (3)].typnam); + (yyval.typnam)->arrayBounds = (yyvsp[(3) - (3)].list); (yyval.typnam)->setof = true; - } -#line 25323 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 788: /* Typename: SimpleTypename ARRAY '[' Iconst ']' */ -#line 1611 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-4].typnam); - (yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[-1].ival))); - } -#line 25332 "third_party/libpg_query/grammar/grammar_out.cpp" + case 790: +#line 1622 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (5)].typnam); + (yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[(4) - (5)].ival))); + ;} break; - case 789: /* Typename: SETOF SimpleTypename ARRAY '[' Iconst ']' */ -#line 1616 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-4].typnam); - (yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[-1].ival))); + case 791: +#line 1627 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(2) - (6)].typnam); + (yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[(5) - (6)].ival))); (yyval.typnam)->setof = true; - } -#line 25342 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 790: /* Typename: SimpleTypename ARRAY */ -#line 1622 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-1].typnam); + case 792: +#line 1633 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (2)].typnam); (yyval.typnam)->arrayBounds = list_make1(makeInteger(-1)); - } -#line 25351 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 791: /* Typename: SETOF SimpleTypename ARRAY */ -#line 1627 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-1].typnam); + case 793: +#line 1638 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(2) - (3)].typnam); (yyval.typnam)->arrayBounds = list_make1(makeInteger(-1)); (yyval.typnam)->setof = true; - } -#line 25361 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 792: /* Typename: qualified_typename */ -#line 1633 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = makeTypeNameFromNameList((yyvsp[0].list)); - } -#line 25369 "third_party/libpg_query/grammar/grammar_out.cpp" + case 794: +#line 1644 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = makeTypeNameFromNameList((yyvsp[(1) - (1)].list)); + ;} break; - case 793: /* Typename: RowOrStruct '(' colid_type_list ')' opt_array_bounds */ -#line 1637 "third_party/libpg_query/grammar/statements/select.y" - { + case 795: +#line 1648 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("struct"); - (yyval.typnam)->arrayBounds = (yyvsp[0].list); - (yyval.typnam)->typmods = (yyvsp[-2].list); - (yyval.typnam)->location = (yylsp[-4]); - } -#line 25380 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->arrayBounds = (yyvsp[(5) - (5)].list); + (yyval.typnam)->typmods = (yyvsp[(3) - (5)].list); + (yyval.typnam)->location = (yylsp[(1) - (5)]); + ;} break; - case 794: /* Typename: MAP '(' type_list ')' opt_array_bounds */ -#line 1644 "third_party/libpg_query/grammar/statements/select.y" - { + case 796: +#line 1655 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("map"); - (yyval.typnam)->arrayBounds = (yyvsp[0].list); - (yyval.typnam)->typmods = (yyvsp[-2].list); - (yyval.typnam)->location = (yylsp[-4]); - } -#line 25391 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->arrayBounds = (yyvsp[(5) - (5)].list); + (yyval.typnam)->typmods = (yyvsp[(3) - (5)].list); + (yyval.typnam)->location = (yylsp[(1) - (5)]); + ;} break; - case 795: /* Typename: UNION '(' colid_type_list ')' opt_array_bounds */ -#line 1651 "third_party/libpg_query/grammar/statements/select.y" - { + case 797: +#line 1662 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("union"); - (yyval.typnam)->arrayBounds = (yyvsp[0].list); - (yyval.typnam)->typmods = (yyvsp[-2].list); - (yyval.typnam)->location = (yylsp[-4]); - } -#line 25402 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->arrayBounds = (yyvsp[(5) - (5)].list); + (yyval.typnam)->typmods = (yyvsp[(3) - (5)].list); + (yyval.typnam)->location = (yylsp[(1) - (5)]); + ;} break; - case 796: /* qualified_typename: IDENT '.' IDENT */ -#line 1660 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2(makeString((yyvsp[-2].str)), makeString((yyvsp[0].str))); } -#line 25408 "third_party/libpg_query/grammar/grammar_out.cpp" + case 798: +#line 1671 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make2(makeString((yyvsp[(1) - (3)].str)), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 797: /* qualified_typename: qualified_typename '.' IDENT */ -#line 1661 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), makeString((yyvsp[0].str))); } -#line 25414 "third_party/libpg_query/grammar/grammar_out.cpp" + case 799: +#line 1672 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 798: /* opt_array_bounds: opt_array_bounds '[' ']' */ -#line 1666 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), makeInteger(-1)); } -#line 25420 "third_party/libpg_query/grammar/grammar_out.cpp" + case 800: +#line 1677 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeInteger(-1)); ;} break; - case 799: /* opt_array_bounds: opt_array_bounds '[' Iconst ']' */ -#line 1668 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-3].list), makeInteger((yyvsp[-1].ival))); } -#line 25426 "third_party/libpg_query/grammar/grammar_out.cpp" + case 801: +#line 1679 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (4)].list), makeInteger((yyvsp[(3) - (4)].ival))); ;} break; - case 800: /* opt_array_bounds: %empty */ -#line 1670 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 25432 "third_party/libpg_query/grammar/grammar_out.cpp" + case 802: +#line 1681 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 801: /* SimpleTypename: GenericType */ -#line 1674 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25438 "third_party/libpg_query/grammar/grammar_out.cpp" + case 803: +#line 1685 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 802: /* SimpleTypename: Numeric */ -#line 1675 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25444 "third_party/libpg_query/grammar/grammar_out.cpp" + case 804: +#line 1686 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 803: /* SimpleTypename: Bit */ -#line 1676 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25450 "third_party/libpg_query/grammar/grammar_out.cpp" + case 805: +#line 1687 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 804: /* SimpleTypename: Character */ -#line 1677 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25456 "third_party/libpg_query/grammar/grammar_out.cpp" + case 806: +#line 1688 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 805: /* SimpleTypename: ConstDatetime */ -#line 1678 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25462 "third_party/libpg_query/grammar/grammar_out.cpp" + case 807: +#line 1689 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 806: /* SimpleTypename: ConstInterval opt_interval */ -#line 1680 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-1].typnam); - (yyval.typnam)->typmods = (yyvsp[0].list); - } -#line 25471 "third_party/libpg_query/grammar/grammar_out.cpp" + case 808: +#line 1691 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (2)].typnam); + (yyval.typnam)->typmods = (yyvsp[(2) - (2)].list); + ;} break; - case 807: /* SimpleTypename: ConstInterval '(' Iconst ')' */ -#line 1685 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-3].typnam); + case 809: +#line 1696 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (4)].typnam); (yyval.typnam)->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1), - makeIntConst((yyvsp[-1].ival), (yylsp[-1]))); - } -#line 25481 "third_party/libpg_query/grammar/grammar_out.cpp" + makeIntConst((yyvsp[(3) - (4)].ival), (yylsp[(3) - (4)]))); + ;} break; - case 808: /* ConstTypename: Numeric */ -#line 1704 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25487 "third_party/libpg_query/grammar/grammar_out.cpp" + case 810: +#line 1715 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 809: /* ConstTypename: ConstBit */ -#line 1705 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25493 "third_party/libpg_query/grammar/grammar_out.cpp" + case 811: +#line 1716 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 810: /* ConstTypename: ConstCharacter */ -#line 1706 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25499 "third_party/libpg_query/grammar/grammar_out.cpp" + case 812: +#line 1717 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 811: /* ConstTypename: ConstDatetime */ -#line 1707 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25505 "third_party/libpg_query/grammar/grammar_out.cpp" + case 813: +#line 1718 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 812: /* GenericType: type_name_token opt_type_modifiers */ -#line 1719 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = makeTypeName((yyvsp[-1].str)); - (yyval.typnam)->typmods = (yyvsp[0].list); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 25515 "third_party/libpg_query/grammar/grammar_out.cpp" + case 814: +#line 1730 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = makeTypeName((yyvsp[(1) - (2)].str)); + (yyval.typnam)->typmods = (yyvsp[(2) - (2)].list); + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 813: /* opt_type_modifiers: '(' opt_expr_list_opt_comma ')' */ -#line 1732 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 25521 "third_party/libpg_query/grammar/grammar_out.cpp" + case 815: +#line 1743 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 814: /* opt_type_modifiers: %empty */ -#line 1733 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 25527 "third_party/libpg_query/grammar/grammar_out.cpp" + case 816: +#line 1744 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 815: /* Numeric: INT_P */ -#line 1740 "third_party/libpg_query/grammar/statements/select.y" - { + case 817: +#line 1751 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("int4"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25536 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 816: /* Numeric: INTEGER */ -#line 1745 "third_party/libpg_query/grammar/statements/select.y" - { + case 818: +#line 1756 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("int4"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25545 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 817: /* Numeric: SMALLINT */ -#line 1750 "third_party/libpg_query/grammar/statements/select.y" - { + case 819: +#line 1761 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("int2"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25554 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 818: /* Numeric: BIGINT */ -#line 1755 "third_party/libpg_query/grammar/statements/select.y" - { + case 820: +#line 1766 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("int8"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25563 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 819: /* Numeric: REAL */ -#line 1760 "third_party/libpg_query/grammar/statements/select.y" - { + case 821: +#line 1771 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("float4"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25572 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 820: /* Numeric: FLOAT_P opt_float */ -#line 1765 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 25581 "third_party/libpg_query/grammar/grammar_out.cpp" + case 822: +#line 1776 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(2) - (2)].typnam); + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 821: /* Numeric: DOUBLE_P PRECISION */ -#line 1770 "third_party/libpg_query/grammar/statements/select.y" - { + case 823: +#line 1781 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("float8"); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 25590 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 822: /* Numeric: DECIMAL_P opt_type_modifiers */ -#line 1775 "third_party/libpg_query/grammar/statements/select.y" - { + case 824: +#line 1786 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("numeric"); - (yyval.typnam)->typmods = (yyvsp[0].list); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 25600 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->typmods = (yyvsp[(2) - (2)].list); + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 823: /* Numeric: DEC opt_type_modifiers */ -#line 1781 "third_party/libpg_query/grammar/statements/select.y" - { + case 825: +#line 1792 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("numeric"); - (yyval.typnam)->typmods = (yyvsp[0].list); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 25610 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->typmods = (yyvsp[(2) - (2)].list); + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 824: /* Numeric: NUMERIC opt_type_modifiers */ -#line 1787 "third_party/libpg_query/grammar/statements/select.y" - { + case 826: +#line 1798 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("numeric"); - (yyval.typnam)->typmods = (yyvsp[0].list); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 25620 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->typmods = (yyvsp[(2) - (2)].list); + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 825: /* Numeric: BOOLEAN_P */ -#line 1793 "third_party/libpg_query/grammar/statements/select.y" - { + case 827: +#line 1804 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("bool"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25629 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 826: /* opt_float: '(' Iconst ')' */ -#line 1800 "third_party/libpg_query/grammar/statements/select.y" - { + case 828: +#line 1811 "third_party/libpg_query/grammar/statements/select.y" + { /* * Check FLOAT() precision limits assuming IEEE floating * types - thomas 1997-09-18 */ - if ((yyvsp[-1].ival) < 1) + if ((yyvsp[(2) - (3)].ival) < 1) ereport(ERROR, (errcode(PG_ERRCODE_INVALID_PARAMETER_VALUE), errmsg("precision for type float must be at least 1 bit"), - parser_errposition((yylsp[-1])))); - else if ((yyvsp[-1].ival) <= 24) + parser_errposition((yylsp[(2) - (3)])))); + else if ((yyvsp[(2) - (3)].ival) <= 24) (yyval.typnam) = SystemTypeName("float4"); - else if ((yyvsp[-1].ival) <= 53) + else if ((yyvsp[(2) - (3)].ival) <= 53) (yyval.typnam) = SystemTypeName("float8"); else ereport(ERROR, (errcode(PG_ERRCODE_INVALID_PARAMETER_VALUE), errmsg("precision for type float must be less than 54 bits"), - parser_errposition((yylsp[-1])))); - } -#line 25654 "third_party/libpg_query/grammar/grammar_out.cpp" + parser_errposition((yylsp[(2) - (3)])))); + ;} break; - case 827: /* opt_float: %empty */ -#line 1821 "third_party/libpg_query/grammar/statements/select.y" - { + case 829: +#line 1832 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("float4"); - } -#line 25662 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 828: /* Bit: BitWithLength */ -#line 1831 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 25670 "third_party/libpg_query/grammar/grammar_out.cpp" + case 830: +#line 1842 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 829: /* Bit: BitWithoutLength */ -#line 1835 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 25678 "third_party/libpg_query/grammar/grammar_out.cpp" + case 831: +#line 1846 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 830: /* ConstBit: BitWithLength */ -#line 1843 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 25686 "third_party/libpg_query/grammar/grammar_out.cpp" + case 832: +#line 1854 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 831: /* ConstBit: BitWithoutLength */ -#line 1847 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); + case 833: +#line 1858 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); (yyval.typnam)->typmods = NIL; - } -#line 25695 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 832: /* BitWithLength: BIT opt_varying '(' expr_list_opt_comma ')' */ -#line 1855 "third_party/libpg_query/grammar/statements/select.y" - { + case 834: +#line 1866 "third_party/libpg_query/grammar/statements/select.y" + { const char *typname; - typname = (yyvsp[-3].boolean) ? "varbit" : "bit"; + typname = (yyvsp[(2) - (5)].boolean) ? "varbit" : "bit"; (yyval.typnam) = SystemTypeName(typname); - (yyval.typnam)->typmods = (yyvsp[-1].list); - (yyval.typnam)->location = (yylsp[-4]); - } -#line 25708 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->typmods = (yyvsp[(4) - (5)].list); + (yyval.typnam)->location = (yylsp[(1) - (5)]); + ;} break; - case 833: /* BitWithoutLength: BIT opt_varying */ -#line 1867 "third_party/libpg_query/grammar/statements/select.y" - { + case 835: +#line 1878 "third_party/libpg_query/grammar/statements/select.y" + { /* bit defaults to bit(1), varbit to no limit */ - if ((yyvsp[0].boolean)) + if ((yyvsp[(2) - (2)].boolean)) { (yyval.typnam) = SystemTypeName("varbit"); } @@ -412236,982 +416030,873 @@ YYLTYPE yylloc = yyloc_default; (yyval.typnam) = SystemTypeName("bit"); (yyval.typnam)->typmods = list_make1(makeIntConst(1, -1)); } - (yyval.typnam)->location = (yylsp[-1]); - } -#line 25726 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 834: /* Character: CharacterWithLength */ -#line 1888 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 25734 "third_party/libpg_query/grammar/grammar_out.cpp" + case 836: +#line 1899 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 835: /* Character: CharacterWithoutLength */ -#line 1892 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 25742 "third_party/libpg_query/grammar/grammar_out.cpp" + case 837: +#line 1903 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 836: /* ConstCharacter: CharacterWithLength */ -#line 1898 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 25750 "third_party/libpg_query/grammar/grammar_out.cpp" + case 838: +#line 1909 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 837: /* ConstCharacter: CharacterWithoutLength */ -#line 1902 "third_party/libpg_query/grammar/statements/select.y" - { + case 839: +#line 1913 "third_party/libpg_query/grammar/statements/select.y" + { /* Length was not specified so allow to be unrestricted. * This handles problems with fixed-length (bpchar) strings * which in column definitions must default to a length * of one, but should not be constrained if the length * was not specified. */ - (yyval.typnam) = (yyvsp[0].typnam); + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); (yyval.typnam)->typmods = NIL; - } -#line 25765 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 838: /* CharacterWithLength: character '(' Iconst ')' */ -#line 1915 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = SystemTypeName((yyvsp[-3].conststr)); - (yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[-1].ival), (yylsp[-1]))); - (yyval.typnam)->location = (yylsp[-3]); - } -#line 25775 "third_party/libpg_query/grammar/grammar_out.cpp" + case 840: +#line 1926 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = SystemTypeName((yyvsp[(1) - (4)].conststr)); + (yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[(3) - (4)].ival), (yylsp[(3) - (4)]))); + (yyval.typnam)->location = (yylsp[(1) - (4)]); + ;} break; - case 839: /* CharacterWithoutLength: character */ -#line 1923 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = SystemTypeName((yyvsp[0].conststr)); + case 841: +#line 1934 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.typnam) = SystemTypeName((yyvsp[(1) - (1)].conststr)); /* char defaults to char(1), varchar to no limit */ - if (strcmp((yyvsp[0].conststr), "bpchar") == 0) + if (strcmp((yyvsp[(1) - (1)].conststr), "bpchar") == 0) (yyval.typnam)->typmods = list_make1(makeIntConst(1, -1)); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25787 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 840: /* character: CHARACTER opt_varying */ -#line 1933 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = (yyvsp[0].boolean) ? "varchar": "bpchar"; } -#line 25793 "third_party/libpg_query/grammar/grammar_out.cpp" + case 842: +#line 1944 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} break; - case 841: /* character: CHAR_P opt_varying */ -#line 1935 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = (yyvsp[0].boolean) ? "varchar": "bpchar"; } -#line 25799 "third_party/libpg_query/grammar/grammar_out.cpp" + case 843: +#line 1946 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} break; - case 842: /* character: VARCHAR */ -#line 1937 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "varchar"; } -#line 25805 "third_party/libpg_query/grammar/grammar_out.cpp" + case 844: +#line 1948 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "varchar"; ;} break; - case 843: /* character: NATIONAL CHARACTER opt_varying */ -#line 1939 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = (yyvsp[0].boolean) ? "varchar": "bpchar"; } -#line 25811 "third_party/libpg_query/grammar/grammar_out.cpp" + case 845: +#line 1950 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;} break; - case 844: /* character: NATIONAL CHAR_P opt_varying */ -#line 1941 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = (yyvsp[0].boolean) ? "varchar": "bpchar"; } -#line 25817 "third_party/libpg_query/grammar/grammar_out.cpp" + case 846: +#line 1952 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;} break; - case 845: /* character: NCHAR opt_varying */ -#line 1943 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = (yyvsp[0].boolean) ? "varchar": "bpchar"; } -#line 25823 "third_party/libpg_query/grammar/grammar_out.cpp" + case 847: +#line 1954 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} break; - case 846: /* opt_varying: VARYING */ -#line 1947 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 25829 "third_party/libpg_query/grammar/grammar_out.cpp" + case 848: +#line 1958 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = true; ;} break; - case 847: /* opt_varying: %empty */ -#line 1948 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 25835 "third_party/libpg_query/grammar/grammar_out.cpp" + case 849: +#line 1959 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = false; ;} break; - case 848: /* ConstDatetime: TIMESTAMP '(' Iconst ')' opt_timezone */ -#line 1956 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].boolean)) + case 850: +#line 1967 "third_party/libpg_query/grammar/statements/select.y" + { + if ((yyvsp[(5) - (5)].boolean)) (yyval.typnam) = SystemTypeName("timestamptz"); else (yyval.typnam) = SystemTypeName("timestamp"); - (yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[-2].ival), (yylsp[-2]))); - (yyval.typnam)->location = (yylsp[-4]); - } -#line 25848 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[(3) - (5)].ival), (yylsp[(3) - (5)]))); + (yyval.typnam)->location = (yylsp[(1) - (5)]); + ;} break; - case 849: /* ConstDatetime: TIMESTAMP opt_timezone */ -#line 1965 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].boolean)) + case 851: +#line 1976 "third_party/libpg_query/grammar/statements/select.y" + { + if ((yyvsp[(2) - (2)].boolean)) (yyval.typnam) = SystemTypeName("timestamptz"); else (yyval.typnam) = SystemTypeName("timestamp"); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 25860 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 850: /* ConstDatetime: TIME '(' Iconst ')' opt_timezone */ -#line 1973 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].boolean)) + case 852: +#line 1984 "third_party/libpg_query/grammar/statements/select.y" + { + if ((yyvsp[(5) - (5)].boolean)) (yyval.typnam) = SystemTypeName("timetz"); else (yyval.typnam) = SystemTypeName("time"); - (yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[-2].ival), (yylsp[-2]))); - (yyval.typnam)->location = (yylsp[-4]); - } -#line 25873 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[(3) - (5)].ival), (yylsp[(3) - (5)]))); + (yyval.typnam)->location = (yylsp[(1) - (5)]); + ;} break; - case 851: /* ConstDatetime: TIME opt_timezone */ -#line 1982 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].boolean)) + case 853: +#line 1993 "third_party/libpg_query/grammar/statements/select.y" + { + if ((yyvsp[(2) - (2)].boolean)) (yyval.typnam) = SystemTypeName("timetz"); else (yyval.typnam) = SystemTypeName("time"); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 25885 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 852: /* ConstInterval: INTERVAL */ -#line 1993 "third_party/libpg_query/grammar/statements/select.y" - { + case 854: +#line 2004 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.typnam) = SystemTypeName("interval"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25894 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 853: /* opt_timezone: WITH_LA TIME ZONE */ -#line 2000 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 25900 "third_party/libpg_query/grammar/grammar_out.cpp" + case 855: +#line 2011 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = true; ;} break; - case 854: /* opt_timezone: WITHOUT TIME ZONE */ -#line 2001 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 25906 "third_party/libpg_query/grammar/grammar_out.cpp" + case 856: +#line 2012 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = false; ;} break; - case 855: /* opt_timezone: %empty */ -#line 2002 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 25912 "third_party/libpg_query/grammar/grammar_out.cpp" + case 857: +#line 2013 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = false; ;} break; - case 880: /* opt_interval: year_keyword */ -#line 2043 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR), (yylsp[0]))); } -#line 25918 "third_party/libpg_query/grammar/grammar_out.cpp" + case 882: +#line 2054 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR), (yylsp[(1) - (1)]))); ;} break; - case 881: /* opt_interval: month_keyword */ -#line 2045 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MONTH), (yylsp[0]))); } -#line 25924 "third_party/libpg_query/grammar/grammar_out.cpp" + case 883: +#line 2056 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MONTH), (yylsp[(1) - (1)]))); ;} break; - case 882: /* opt_interval: day_keyword */ -#line 2047 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY), (yylsp[0]))); } -#line 25930 "third_party/libpg_query/grammar/grammar_out.cpp" + case 884: +#line 2058 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY), (yylsp[(1) - (1)]))); ;} break; - case 883: /* opt_interval: hour_keyword */ -#line 2049 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR), (yylsp[0]))); } -#line 25936 "third_party/libpg_query/grammar/grammar_out.cpp" + case 885: +#line 2060 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR), (yylsp[(1) - (1)]))); ;} break; - case 884: /* opt_interval: minute_keyword */ -#line 2051 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE), (yylsp[0]))); } -#line 25942 "third_party/libpg_query/grammar/grammar_out.cpp" + case 886: +#line 2062 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE), (yylsp[(1) - (1)]))); ;} break; - case 885: /* opt_interval: second_keyword */ -#line 2053 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(SECOND), (yylsp[0]))); } -#line 25948 "third_party/libpg_query/grammar/grammar_out.cpp" + case 887: +#line 2064 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(SECOND), (yylsp[(1) - (1)]))); ;} break; - case 886: /* opt_interval: millisecond_keyword */ -#line 2055 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLISECOND), (yylsp[0]))); } -#line 25954 "third_party/libpg_query/grammar/grammar_out.cpp" + case 888: +#line 2066 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLISECOND), (yylsp[(1) - (1)]))); ;} break; - case 887: /* opt_interval: microsecond_keyword */ -#line 2057 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MICROSECOND), (yylsp[0]))); } -#line 25960 "third_party/libpg_query/grammar/grammar_out.cpp" + case 889: +#line 2068 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MICROSECOND), (yylsp[(1) - (1)]))); ;} break; - case 888: /* opt_interval: week_keyword */ -#line 2059 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(WEEK), (yylsp[0]))); } -#line 25966 "third_party/libpg_query/grammar/grammar_out.cpp" + case 890: +#line 2070 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(WEEK), (yylsp[(1) - (1)]))); ;} break; - case 889: /* opt_interval: decade_keyword */ -#line 2061 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DECADE), (yylsp[0]))); } -#line 25972 "third_party/libpg_query/grammar/grammar_out.cpp" + case 891: +#line 2072 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DECADE), (yylsp[(1) - (1)]))); ;} break; - case 890: /* opt_interval: century_keyword */ -#line 2063 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(CENTURY), (yylsp[0]))); } -#line 25978 "third_party/libpg_query/grammar/grammar_out.cpp" + case 892: +#line 2074 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(CENTURY), (yylsp[(1) - (1)]))); ;} break; - case 891: /* opt_interval: millennium_keyword */ -#line 2065 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLENNIUM), (yylsp[0]))); } -#line 25984 "third_party/libpg_query/grammar/grammar_out.cpp" + case 893: +#line 2076 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLENNIUM), (yylsp[(1) - (1)]))); ;} break; - case 892: /* opt_interval: year_keyword TO month_keyword */ -#line 2067 "third_party/libpg_query/grammar/statements/select.y" - { + case 894: +#line 2078 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR) | - INTERVAL_MASK(MONTH), (yylsp[-2]))); - } -#line 25993 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(MONTH), (yylsp[(1) - (3)]))); + ;} break; - case 893: /* opt_interval: day_keyword TO hour_keyword */ -#line 2072 "third_party/libpg_query/grammar/statements/select.y" - { + case 895: +#line 2083 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) | - INTERVAL_MASK(HOUR), (yylsp[-2]))); - } -#line 26002 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(HOUR), (yylsp[(1) - (3)]))); + ;} break; - case 894: /* opt_interval: day_keyword TO minute_keyword */ -#line 2077 "third_party/libpg_query/grammar/statements/select.y" - { + case 896: +#line 2088 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | - INTERVAL_MASK(MINUTE), (yylsp[-2]))); - } -#line 26012 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(MINUTE), (yylsp[(1) - (3)]))); + ;} break; - case 895: /* opt_interval: day_keyword TO second_keyword */ -#line 2083 "third_party/libpg_query/grammar/statements/select.y" - { + case 897: +#line 2094 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | - INTERVAL_MASK(SECOND), (yylsp[-2]))); - } -#line 26023 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(SECOND), (yylsp[(1) - (3)]))); + ;} break; - case 896: /* opt_interval: hour_keyword TO minute_keyword */ -#line 2090 "third_party/libpg_query/grammar/statements/select.y" - { + case 898: +#line 2101 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR) | - INTERVAL_MASK(MINUTE), (yylsp[-2]))); - } -#line 26032 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(MINUTE), (yylsp[(1) - (3)]))); + ;} break; - case 897: /* opt_interval: hour_keyword TO second_keyword */ -#line 2095 "third_party/libpg_query/grammar/statements/select.y" - { + case 899: +#line 2106 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | - INTERVAL_MASK(SECOND), (yylsp[-2]))); - } -#line 26042 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(SECOND), (yylsp[(1) - (3)]))); + ;} break; - case 898: /* opt_interval: minute_keyword TO second_keyword */ -#line 2101 "third_party/libpg_query/grammar/statements/select.y" - { + case 900: +#line 2112 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE) | - INTERVAL_MASK(SECOND), (yylsp[-2]))); - } -#line 26051 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(SECOND), (yylsp[(1) - (3)]))); + ;} break; - case 899: /* opt_interval: %empty */ -#line 2106 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 26057 "third_party/libpg_query/grammar/grammar_out.cpp" + case 901: +#line 2117 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 900: /* a_expr: c_expr */ -#line 2137 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 26063 "third_party/libpg_query/grammar/grammar_out.cpp" + case 902: +#line 2148 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 901: /* a_expr: a_expr TYPECAST Typename */ -#line 2140 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeTypeCast((yyvsp[-2].node), (yyvsp[0].typnam), 0, (yylsp[-1])); } -#line 26069 "third_party/libpg_query/grammar/grammar_out.cpp" + case 903: +#line 2151 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), 0, (yylsp[(2) - (3)])); ;} break; - case 902: /* a_expr: a_expr COLLATE any_name */ -#line 2142 "third_party/libpg_query/grammar/statements/select.y" - { + case 904: +#line 2153 "third_party/libpg_query/grammar/statements/select.y" + { PGCollateClause *n = makeNode(PGCollateClause); - n->arg = (yyvsp[-2].node); - n->collname = (yyvsp[0].list); - n->location = (yylsp[-1]); + n->arg = (yyvsp[(1) - (3)].node); + n->collname = (yyvsp[(3) - (3)].list); + n->location = (yylsp[(2) - (3)]); (yyval.node) = (PGNode *) n; - } -#line 26081 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 903: /* a_expr: a_expr AT TIME ZONE a_expr */ -#line 2150 "third_party/libpg_query/grammar/statements/select.y" - { + case 905: +#line 2161 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("timezone"), - list_make2((yyvsp[0].node), (yyvsp[-4].node)), - (yylsp[-3])); - } -#line 26091 "third_party/libpg_query/grammar/grammar_out.cpp" + list_make2((yyvsp[(5) - (5)].node), (yyvsp[(1) - (5)].node)), + (yylsp[(2) - (5)])); + ;} break; - case 904: /* a_expr: '+' a_expr */ -#line 2165 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[0].node), (yylsp[-1])); } -#line 26097 "third_party/libpg_query/grammar/grammar_out.cpp" + case 906: +#line 2176 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 905: /* a_expr: '-' a_expr */ -#line 2167 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = doNegate((yyvsp[0].node), (yylsp[-1])); } -#line 26103 "third_party/libpg_query/grammar/grammar_out.cpp" + case 907: +#line 2178 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 906: /* a_expr: a_expr '+' a_expr */ -#line 2169 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26109 "third_party/libpg_query/grammar/grammar_out.cpp" + case 908: +#line 2180 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 907: /* a_expr: a_expr '-' a_expr */ -#line 2171 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26115 "third_party/libpg_query/grammar/grammar_out.cpp" + case 909: +#line 2182 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 908: /* a_expr: a_expr '*' a_expr */ -#line 2173 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "*", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26121 "third_party/libpg_query/grammar/grammar_out.cpp" + case 910: +#line 2184 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "*", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 909: /* a_expr: a_expr '/' a_expr */ -#line 2175 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "/", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26127 "third_party/libpg_query/grammar/grammar_out.cpp" + case 911: +#line 2186 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "/", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 910: /* a_expr: a_expr INTEGER_DIVISION a_expr */ -#line 2177 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "//", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26133 "third_party/libpg_query/grammar/grammar_out.cpp" + case 912: +#line 2188 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "//", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 911: /* a_expr: a_expr '%' a_expr */ -#line 2179 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "%", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26139 "third_party/libpg_query/grammar/grammar_out.cpp" + case 913: +#line 2190 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "%", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 912: /* a_expr: a_expr '^' a_expr */ -#line 2181 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26145 "third_party/libpg_query/grammar/grammar_out.cpp" + case 914: +#line 2192 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 913: /* a_expr: a_expr POWER_OF a_expr */ -#line 2183 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26151 "third_party/libpg_query/grammar/grammar_out.cpp" + case 915: +#line 2194 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 914: /* a_expr: a_expr '<' a_expr */ -#line 2185 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26157 "third_party/libpg_query/grammar/grammar_out.cpp" + case 916: +#line 2196 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 915: /* a_expr: a_expr '>' a_expr */ -#line 2187 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26163 "third_party/libpg_query/grammar/grammar_out.cpp" + case 917: +#line 2198 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 916: /* a_expr: a_expr '=' a_expr */ -#line 2189 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26169 "third_party/libpg_query/grammar/grammar_out.cpp" + case 918: +#line 2200 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 917: /* a_expr: a_expr LESS_EQUALS a_expr */ -#line 2191 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26175 "third_party/libpg_query/grammar/grammar_out.cpp" + case 919: +#line 2202 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 918: /* a_expr: a_expr GREATER_EQUALS a_expr */ -#line 2193 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26181 "third_party/libpg_query/grammar/grammar_out.cpp" + case 920: +#line 2204 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 919: /* a_expr: a_expr NOT_EQUALS a_expr */ -#line 2195 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26187 "third_party/libpg_query/grammar/grammar_out.cpp" + case 921: +#line 2206 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 920: /* a_expr: a_expr qual_Op a_expr */ -#line 2198 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[-1].list), (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26193 "third_party/libpg_query/grammar/grammar_out.cpp" + case 922: +#line 2209 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 921: /* a_expr: qual_Op a_expr */ -#line 2200 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[-1].list), NULL, (yyvsp[0].node), (yylsp[-1])); } -#line 26199 "third_party/libpg_query/grammar/grammar_out.cpp" + case 923: +#line 2211 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 922: /* a_expr: a_expr qual_Op */ -#line 2202 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[0].list), (yyvsp[-1].node), NULL, (yylsp[0])); } -#line 26205 "third_party/libpg_query/grammar/grammar_out.cpp" + case 924: +#line 2213 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;} break; - case 923: /* a_expr: a_expr AND a_expr */ -#line 2205 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeAndExpr((yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26211 "third_party/libpg_query/grammar/grammar_out.cpp" + case 925: +#line 2216 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = makeAndExpr((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 924: /* a_expr: a_expr OR a_expr */ -#line 2207 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeOrExpr((yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26217 "third_party/libpg_query/grammar/grammar_out.cpp" + case 926: +#line 2218 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = makeOrExpr((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 925: /* a_expr: NOT a_expr */ -#line 2209 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeNotExpr((yyvsp[0].node), (yylsp[-1])); } -#line 26223 "third_party/libpg_query/grammar/grammar_out.cpp" + case 927: +#line 2220 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = makeNotExpr((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 926: /* a_expr: NOT_LA a_expr */ -#line 2211 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeNotExpr((yyvsp[0].node), (yylsp[-1])); } -#line 26229 "third_party/libpg_query/grammar/grammar_out.cpp" + case 928: +#line 2222 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = makeNotExpr((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 927: /* a_expr: a_expr GLOB a_expr */ -#line 2213 "third_party/libpg_query/grammar/statements/select.y" - { + case 929: +#line 2224 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_GLOB, "~~~", - (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); - } -#line 26238 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); + ;} break; - case 928: /* a_expr: a_expr LIKE a_expr */ -#line 2218 "third_party/libpg_query/grammar/statements/select.y" - { + case 930: +#line 2229 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_LIKE, "~~", - (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); - } -#line 26247 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); + ;} break; - case 929: /* a_expr: a_expr LIKE a_expr ESCAPE a_expr */ -#line 2223 "third_party/libpg_query/grammar/statements/select.y" - { + case 931: +#line 2234 "third_party/libpg_query/grammar/statements/select.y" + { PGFuncCall *n = makeFuncCall(SystemFuncName("like_escape"), - list_make3((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node)), - (yylsp[-3])); + list_make3((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)), + (yylsp[(2) - (5)])); (yyval.node) = (PGNode *) n; - } -#line 26258 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 930: /* a_expr: a_expr NOT_LA LIKE a_expr */ -#line 2230 "third_party/libpg_query/grammar/statements/select.y" - { + case 932: +#line 2241 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_LIKE, "!~~", - (yyvsp[-3].node), (yyvsp[0].node), (yylsp[-2])); - } -#line 26267 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)])); + ;} break; - case 931: /* a_expr: a_expr NOT_LA LIKE a_expr ESCAPE a_expr */ -#line 2235 "third_party/libpg_query/grammar/statements/select.y" - { + case 933: +#line 2246 "third_party/libpg_query/grammar/statements/select.y" + { PGFuncCall *n = makeFuncCall(SystemFuncName("not_like_escape"), - list_make3((yyvsp[-5].node), (yyvsp[-2].node), (yyvsp[0].node)), - (yylsp[-4])); + list_make3((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)), + (yylsp[(2) - (6)])); (yyval.node) = (PGNode *) n; - } -#line 26278 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 932: /* a_expr: a_expr ILIKE a_expr */ -#line 2242 "third_party/libpg_query/grammar/statements/select.y" - { + case 934: +#line 2253 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_ILIKE, "~~*", - (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); - } -#line 26287 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); + ;} break; - case 933: /* a_expr: a_expr ILIKE a_expr ESCAPE a_expr */ -#line 2247 "third_party/libpg_query/grammar/statements/select.y" - { + case 935: +#line 2258 "third_party/libpg_query/grammar/statements/select.y" + { PGFuncCall *n = makeFuncCall(SystemFuncName("ilike_escape"), - list_make3((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node)), - (yylsp[-3])); + list_make3((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)), + (yylsp[(2) - (5)])); (yyval.node) = (PGNode *) n; - } -#line 26298 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 934: /* a_expr: a_expr NOT_LA ILIKE a_expr */ -#line 2254 "third_party/libpg_query/grammar/statements/select.y" - { + case 936: +#line 2265 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_ILIKE, "!~~*", - (yyvsp[-3].node), (yyvsp[0].node), (yylsp[-2])); - } -#line 26307 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)])); + ;} break; - case 935: /* a_expr: a_expr NOT_LA ILIKE a_expr ESCAPE a_expr */ -#line 2259 "third_party/libpg_query/grammar/statements/select.y" - { + case 937: +#line 2270 "third_party/libpg_query/grammar/statements/select.y" + { PGFuncCall *n = makeFuncCall(SystemFuncName("not_ilike_escape"), - list_make3((yyvsp[-5].node), (yyvsp[-2].node), (yyvsp[0].node)), - (yylsp[-4])); + list_make3((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)), + (yylsp[(2) - (6)])); (yyval.node) = (PGNode *) n; - } -#line 26318 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 936: /* a_expr: a_expr SIMILAR TO a_expr */ -#line 2267 "third_party/libpg_query/grammar/statements/select.y" - { + case 938: +#line 2278 "third_party/libpg_query/grammar/statements/select.y" + { PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"), - list_make2((yyvsp[0].node), makeNullAConst(-1)), - (yylsp[-2])); + list_make2((yyvsp[(4) - (4)].node), makeNullAConst(-1)), + (yylsp[(2) - (4)])); (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "~", - (yyvsp[-3].node), (PGNode *) n, (yylsp[-2])); - } -#line 26330 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (4)].node), (PGNode *) n, (yylsp[(2) - (4)])); + ;} break; - case 937: /* a_expr: a_expr SIMILAR TO a_expr ESCAPE a_expr */ -#line 2275 "third_party/libpg_query/grammar/statements/select.y" - { + case 939: +#line 2286 "third_party/libpg_query/grammar/statements/select.y" + { PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"), - list_make2((yyvsp[-2].node), (yyvsp[0].node)), - (yylsp[-4])); + list_make2((yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)), + (yylsp[(2) - (6)])); (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "~", - (yyvsp[-5].node), (PGNode *) n, (yylsp[-4])); - } -#line 26342 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (6)].node), (PGNode *) n, (yylsp[(2) - (6)])); + ;} break; - case 938: /* a_expr: a_expr NOT_LA SIMILAR TO a_expr */ -#line 2283 "third_party/libpg_query/grammar/statements/select.y" - { + case 940: +#line 2294 "third_party/libpg_query/grammar/statements/select.y" + { PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"), - list_make2((yyvsp[0].node), makeNullAConst(-1)), - (yylsp[-3])); + list_make2((yyvsp[(5) - (5)].node), makeNullAConst(-1)), + (yylsp[(2) - (5)])); (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "!~", - (yyvsp[-4].node), (PGNode *) n, (yylsp[-3])); - } -#line 26354 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (5)].node), (PGNode *) n, (yylsp[(2) - (5)])); + ;} break; - case 939: /* a_expr: a_expr NOT_LA SIMILAR TO a_expr ESCAPE a_expr */ -#line 2291 "third_party/libpg_query/grammar/statements/select.y" - { + case 941: +#line 2302 "third_party/libpg_query/grammar/statements/select.y" + { PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"), - list_make2((yyvsp[-2].node), (yyvsp[0].node)), - (yylsp[-5])); + list_make2((yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node)), + (yylsp[(2) - (7)])); (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "!~", - (yyvsp[-6].node), (PGNode *) n, (yylsp[-5])); - } -#line 26366 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (7)].node), (PGNode *) n, (yylsp[(2) - (7)])); + ;} break; - case 940: /* a_expr: a_expr IS NULL_P */ -#line 2309 "third_party/libpg_query/grammar/statements/select.y" - { + case 942: +#line 2320 "third_party/libpg_query/grammar/statements/select.y" + { PGNullTest *n = makeNode(PGNullTest); - n->arg = (PGExpr *) (yyvsp[-2].node); + n->arg = (PGExpr *) (yyvsp[(1) - (3)].node); n->nulltesttype = PG_IS_NULL; - n->location = (yylsp[-1]); + n->location = (yylsp[(2) - (3)]); (yyval.node) = (PGNode *)n; - } -#line 26378 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 941: /* a_expr: a_expr ISNULL */ -#line 2317 "third_party/libpg_query/grammar/statements/select.y" - { + case 943: +#line 2328 "third_party/libpg_query/grammar/statements/select.y" + { PGNullTest *n = makeNode(PGNullTest); - n->arg = (PGExpr *) (yyvsp[-1].node); + n->arg = (PGExpr *) (yyvsp[(1) - (2)].node); n->nulltesttype = PG_IS_NULL; - n->location = (yylsp[0]); + n->location = (yylsp[(2) - (2)]); (yyval.node) = (PGNode *)n; - } -#line 26390 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 942: /* a_expr: a_expr IS NOT NULL_P */ -#line 2325 "third_party/libpg_query/grammar/statements/select.y" - { + case 944: +#line 2336 "third_party/libpg_query/grammar/statements/select.y" + { PGNullTest *n = makeNode(PGNullTest); - n->arg = (PGExpr *) (yyvsp[-3].node); + n->arg = (PGExpr *) (yyvsp[(1) - (4)].node); n->nulltesttype = IS_NOT_NULL; - n->location = (yylsp[-2]); + n->location = (yylsp[(2) - (4)]); (yyval.node) = (PGNode *)n; - } -#line 26402 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 943: /* a_expr: a_expr NOT NULL_P */ -#line 2333 "third_party/libpg_query/grammar/statements/select.y" - { + case 945: +#line 2344 "third_party/libpg_query/grammar/statements/select.y" + { PGNullTest *n = makeNode(PGNullTest); - n->arg = (PGExpr *) (yyvsp[-2].node); + n->arg = (PGExpr *) (yyvsp[(1) - (3)].node); n->nulltesttype = IS_NOT_NULL; - n->location = (yylsp[-1]); + n->location = (yylsp[(2) - (3)]); (yyval.node) = (PGNode *)n; - } -#line 26414 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 944: /* a_expr: a_expr NOTNULL */ -#line 2341 "third_party/libpg_query/grammar/statements/select.y" - { + case 946: +#line 2352 "third_party/libpg_query/grammar/statements/select.y" + { PGNullTest *n = makeNode(PGNullTest); - n->arg = (PGExpr *) (yyvsp[-1].node); + n->arg = (PGExpr *) (yyvsp[(1) - (2)].node); n->nulltesttype = IS_NOT_NULL; - n->location = (yylsp[0]); + n->location = (yylsp[(2) - (2)]); (yyval.node) = (PGNode *)n; - } -#line 26426 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 945: /* a_expr: a_expr LAMBDA_ARROW a_expr */ -#line 2349 "third_party/libpg_query/grammar/statements/select.y" - { + case 947: +#line 2360 "third_party/libpg_query/grammar/statements/select.y" + { PGLambdaFunction *n = makeNode(PGLambdaFunction); - n->lhs = (yyvsp[-2].node); - n->rhs = (yyvsp[0].node); - n->location = (yylsp[-1]); + n->lhs = (yyvsp[(1) - (3)].node); + n->rhs = (yyvsp[(3) - (3)].node); + n->location = (yylsp[(2) - (3)]); (yyval.node) = (PGNode *) n; - } -#line 26438 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 946: /* a_expr: a_expr DOUBLE_ARROW a_expr */ -#line 2357 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "->>", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); - } -#line 26446 "third_party/libpg_query/grammar/grammar_out.cpp" + case 948: +#line 2368 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "->>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); + ;} break; - case 947: /* a_expr: row OVERLAPS row */ -#line 2361 "third_party/libpg_query/grammar/statements/select.y" - { - if (list_length((yyvsp[-2].list)) != 2) + case 949: +#line 2372 "third_party/libpg_query/grammar/statements/select.y" + { + if (list_length((yyvsp[(1) - (3)].list)) != 2) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("wrong number of parameters on left side of OVERLAPS expression"), - parser_errposition((yylsp[-2])))); - if (list_length((yyvsp[0].list)) != 2) + parser_errposition((yylsp[(1) - (3)])))); + if (list_length((yyvsp[(3) - (3)].list)) != 2) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("wrong number of parameters on right side of OVERLAPS expression"), - parser_errposition((yylsp[0])))); + parser_errposition((yylsp[(3) - (3)])))); (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("overlaps"), - list_concat((yyvsp[-2].list), (yyvsp[0].list)), - (yylsp[-1])); - } -#line 26466 "third_party/libpg_query/grammar/grammar_out.cpp" + list_concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)), + (yylsp[(2) - (3)])); + ;} break; - case 948: /* a_expr: a_expr IS TRUE_P */ -#line 2377 "third_party/libpg_query/grammar/statements/select.y" - { + case 950: +#line 2388 "third_party/libpg_query/grammar/statements/select.y" + { PGBooleanTest *b = makeNode(PGBooleanTest); - b->arg = (PGExpr *) (yyvsp[-2].node); + b->arg = (PGExpr *) (yyvsp[(1) - (3)].node); b->booltesttype = PG_IS_TRUE; - b->location = (yylsp[-1]); + b->location = (yylsp[(2) - (3)]); (yyval.node) = (PGNode *)b; - } -#line 26478 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 949: /* a_expr: a_expr IS NOT TRUE_P */ -#line 2385 "third_party/libpg_query/grammar/statements/select.y" - { + case 951: +#line 2396 "third_party/libpg_query/grammar/statements/select.y" + { PGBooleanTest *b = makeNode(PGBooleanTest); - b->arg = (PGExpr *) (yyvsp[-3].node); + b->arg = (PGExpr *) (yyvsp[(1) - (4)].node); b->booltesttype = IS_NOT_TRUE; - b->location = (yylsp[-2]); + b->location = (yylsp[(2) - (4)]); (yyval.node) = (PGNode *)b; - } -#line 26490 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 950: /* a_expr: a_expr IS FALSE_P */ -#line 2393 "third_party/libpg_query/grammar/statements/select.y" - { + case 952: +#line 2404 "third_party/libpg_query/grammar/statements/select.y" + { PGBooleanTest *b = makeNode(PGBooleanTest); - b->arg = (PGExpr *) (yyvsp[-2].node); + b->arg = (PGExpr *) (yyvsp[(1) - (3)].node); b->booltesttype = IS_FALSE; - b->location = (yylsp[-1]); + b->location = (yylsp[(2) - (3)]); (yyval.node) = (PGNode *)b; - } -#line 26502 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 951: /* a_expr: a_expr IS NOT FALSE_P */ -#line 2401 "third_party/libpg_query/grammar/statements/select.y" - { + case 953: +#line 2412 "third_party/libpg_query/grammar/statements/select.y" + { PGBooleanTest *b = makeNode(PGBooleanTest); - b->arg = (PGExpr *) (yyvsp[-3].node); + b->arg = (PGExpr *) (yyvsp[(1) - (4)].node); b->booltesttype = IS_NOT_FALSE; - b->location = (yylsp[-2]); + b->location = (yylsp[(2) - (4)]); (yyval.node) = (PGNode *)b; - } -#line 26514 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 952: /* a_expr: a_expr IS UNKNOWN */ -#line 2409 "third_party/libpg_query/grammar/statements/select.y" - { + case 954: +#line 2420 "third_party/libpg_query/grammar/statements/select.y" + { PGBooleanTest *b = makeNode(PGBooleanTest); - b->arg = (PGExpr *) (yyvsp[-2].node); + b->arg = (PGExpr *) (yyvsp[(1) - (3)].node); b->booltesttype = IS_UNKNOWN; - b->location = (yylsp[-1]); + b->location = (yylsp[(2) - (3)]); (yyval.node) = (PGNode *)b; - } -#line 26526 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 953: /* a_expr: a_expr IS NOT UNKNOWN */ -#line 2417 "third_party/libpg_query/grammar/statements/select.y" - { + case 955: +#line 2428 "third_party/libpg_query/grammar/statements/select.y" + { PGBooleanTest *b = makeNode(PGBooleanTest); - b->arg = (PGExpr *) (yyvsp[-3].node); + b->arg = (PGExpr *) (yyvsp[(1) - (4)].node); b->booltesttype = IS_NOT_UNKNOWN; - b->location = (yylsp[-2]); + b->location = (yylsp[(2) - (4)]); (yyval.node) = (PGNode *)b; - } -#line 26538 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 954: /* a_expr: a_expr IS DISTINCT FROM a_expr */ -#line 2425 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[-4].node), (yyvsp[0].node), (yylsp[-3])); - } -#line 26546 "third_party/libpg_query/grammar/grammar_out.cpp" + case 956: +#line 2436 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)])); + ;} break; - case 955: /* a_expr: a_expr IS NOT DISTINCT FROM a_expr */ -#line 2429 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[-5].node), (yyvsp[0].node), (yylsp[-4])); - } -#line 26554 "third_party/libpg_query/grammar/grammar_out.cpp" + case 957: +#line 2440 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[(1) - (6)].node), (yyvsp[(6) - (6)].node), (yylsp[(2) - (6)])); + ;} break; - case 956: /* a_expr: a_expr IS OF '(' type_list ')' */ -#line 2433 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[-5].node), (PGNode *) (yyvsp[-1].list), (yylsp[-4])); - } -#line 26562 "third_party/libpg_query/grammar/grammar_out.cpp" + case 958: +#line 2444 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (PGNode *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)])); + ;} break; - case 957: /* a_expr: a_expr IS NOT OF '(' type_list ')' */ -#line 2437 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[-6].node), (PGNode *) (yyvsp[-1].list), (yylsp[-5])); - } -#line 26570 "third_party/libpg_query/grammar/grammar_out.cpp" + case 959: +#line 2448 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (PGNode *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)])); + ;} break; - case 958: /* a_expr: a_expr BETWEEN opt_asymmetric b_expr AND a_expr */ -#line 2441 "third_party/libpg_query/grammar/statements/select.y" - { + case 960: +#line 2452 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_BETWEEN, "BETWEEN", - (yyvsp[-5].node), - (PGNode *) list_make2((yyvsp[-2].node), (yyvsp[0].node)), - (yylsp[-4])); - } -#line 26582 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (6)].node), + (PGNode *) list_make2((yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)), + (yylsp[(2) - (6)])); + ;} break; - case 959: /* a_expr: a_expr NOT_LA BETWEEN opt_asymmetric b_expr AND a_expr */ -#line 2449 "third_party/libpg_query/grammar/statements/select.y" - { + case 961: +#line 2460 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_BETWEEN, "NOT BETWEEN", - (yyvsp[-6].node), - (PGNode *) list_make2((yyvsp[-2].node), (yyvsp[0].node)), - (yylsp[-5])); - } -#line 26594 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (7)].node), + (PGNode *) list_make2((yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node)), + (yylsp[(2) - (7)])); + ;} break; - case 960: /* a_expr: a_expr BETWEEN SYMMETRIC b_expr AND a_expr */ -#line 2457 "third_party/libpg_query/grammar/statements/select.y" - { + case 962: +#line 2468 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_BETWEEN_SYM, "BETWEEN SYMMETRIC", - (yyvsp[-5].node), - (PGNode *) list_make2((yyvsp[-2].node), (yyvsp[0].node)), - (yylsp[-4])); - } -#line 26606 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (6)].node), + (PGNode *) list_make2((yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)), + (yylsp[(2) - (6)])); + ;} break; - case 961: /* a_expr: a_expr NOT_LA BETWEEN SYMMETRIC b_expr AND a_expr */ -#line 2465 "third_party/libpg_query/grammar/statements/select.y" - { + case 963: +#line 2476 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_BETWEEN_SYM, "NOT BETWEEN SYMMETRIC", - (yyvsp[-6].node), - (PGNode *) list_make2((yyvsp[-2].node), (yyvsp[0].node)), - (yylsp[-5])); - } -#line 26618 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (7)].node), + (PGNode *) list_make2((yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node)), + (yylsp[(2) - (7)])); + ;} break; - case 962: /* a_expr: a_expr IN_P in_expr */ -#line 2473 "third_party/libpg_query/grammar/statements/select.y" - { + case 964: +#line 2484 "third_party/libpg_query/grammar/statements/select.y" + { /* in_expr returns a PGSubLink or a list of a_exprs */ - if (IsA((yyvsp[0].node), PGSubLink)) + if (IsA((yyvsp[(3) - (3)].node), PGSubLink)) { /* generate foo = ANY (subquery) */ - PGSubLink *n = (PGSubLink *) (yyvsp[0].node); + PGSubLink *n = (PGSubLink *) (yyvsp[(3) - (3)].node); n->subLinkType = PG_ANY_SUBLINK; n->subLinkId = 0; - n->testexpr = (yyvsp[-2].node); + n->testexpr = (yyvsp[(1) - (3)].node); n->operName = NIL; /* show it's IN not = ANY */ - n->location = (yylsp[-1]); + n->location = (yylsp[(2) - (3)]); (yyval.node) = (PGNode *)n; } else { /* generate scalar IN expression */ - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_IN, "=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_IN, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); } - } -#line 26642 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 963: /* a_expr: a_expr NOT_LA IN_P in_expr */ -#line 2493 "third_party/libpg_query/grammar/statements/select.y" - { + case 965: +#line 2504 "third_party/libpg_query/grammar/statements/select.y" + { /* in_expr returns a PGSubLink or a list of a_exprs */ - if (IsA((yyvsp[0].node), PGSubLink)) + if (IsA((yyvsp[(4) - (4)].node), PGSubLink)) { /* generate NOT (foo = ANY (subquery)) */ /* Make an = ANY node */ - PGSubLink *n = (PGSubLink *) (yyvsp[0].node); + PGSubLink *n = (PGSubLink *) (yyvsp[(4) - (4)].node); n->subLinkType = PG_ANY_SUBLINK; n->subLinkId = 0; - n->testexpr = (yyvsp[-3].node); + n->testexpr = (yyvsp[(1) - (4)].node); n->operName = NIL; /* show it's IN not = ANY */ - n->location = (yylsp[-2]); + n->location = (yylsp[(2) - (4)]); /* Stick a NOT on top; must have same parse location */ - (yyval.node) = makeNotExpr((PGNode *) n, (yylsp[-2])); + (yyval.node) = makeNotExpr((PGNode *) n, (yylsp[(2) - (4)])); } else { /* generate scalar NOT IN expression */ - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_IN, "<>", (yyvsp[-3].node), (yyvsp[0].node), (yylsp[-2])); + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_IN, "<>", (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)])); } - } -#line 26668 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 964: /* a_expr: a_expr subquery_Op sub_type select_with_parens */ -#line 2515 "third_party/libpg_query/grammar/statements/select.y" - { + case 966: +#line 2526 "third_party/libpg_query/grammar/statements/select.y" + { PGSubLink *n = makeNode(PGSubLink); - n->subLinkType = (yyvsp[-1].subquerytype); + n->subLinkType = (yyvsp[(3) - (4)].subquerytype); n->subLinkId = 0; - n->testexpr = (yyvsp[-3].node); - n->operName = (yyvsp[-2].list); - n->subselect = (yyvsp[0].node); - n->location = (yylsp[-2]); + n->testexpr = (yyvsp[(1) - (4)].node); + n->operName = (yyvsp[(2) - (4)].list); + n->subselect = (yyvsp[(4) - (4)].node); + n->location = (yylsp[(2) - (4)]); (yyval.node) = (PGNode *)n; - } -#line 26683 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 965: /* a_expr: a_expr subquery_Op sub_type '(' a_expr ')' */ -#line 2526 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[-3].subquerytype) == PG_ANY_SUBLINK) - (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP_ANY, (yyvsp[-4].list), (yyvsp[-5].node), (yyvsp[-1].node), (yylsp[-4])); + case 967: +#line 2537 "third_party/libpg_query/grammar/statements/select.y" + { + if ((yyvsp[(3) - (6)].subquerytype) == PG_ANY_SUBLINK) + (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP_ANY, (yyvsp[(2) - (6)].list), (yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].node), (yylsp[(2) - (6)])); else - (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP_ALL, (yyvsp[-4].list), (yyvsp[-5].node), (yyvsp[-1].node), (yylsp[-4])); - } -#line 26694 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP_ALL, (yyvsp[(2) - (6)].list), (yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].node), (yylsp[(2) - (6)])); + ;} break; - case 966: /* a_expr: DEFAULT */ -#line 2533 "third_party/libpg_query/grammar/statements/select.y" - { + case 968: +#line 2544 "third_party/libpg_query/grammar/statements/select.y" + { /* * The SQL spec only allows DEFAULT in "contextually typed * expressions", but for us, it's easier to allow it in @@ -413221,329 +416906,220 @@ YYLTYPE yylloc = yyloc_default; */ PGSetToDefault *n = makeNode(PGSetToDefault); /* parse analysis will fill in the rest */ - n->location = (yylsp[0]); + n->location = (yylsp[(1) - (1)]); (yyval.node) = (PGNode *)n; - } -#line 26712 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 967: /* a_expr: COLUMNS '(' a_expr ')' */ -#line 2547 "third_party/libpg_query/grammar/statements/select.y" - { + case 969: +#line 2558 "third_party/libpg_query/grammar/statements/select.y" + { PGAStar *star = makeNode(PGAStar); - star->expr = (yyvsp[-1].node); + star->expr = (yyvsp[(3) - (4)].node); star->columns = true; - star->location = (yylsp[-3]); + star->location = (yylsp[(1) - (4)]); (yyval.node) = (PGNode *) star; - } -#line 26724 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 968: /* a_expr: '*' opt_except_list opt_replace_list */ -#line 2555 "third_party/libpg_query/grammar/statements/select.y" - { + case 970: +#line 2566 "third_party/libpg_query/grammar/statements/select.y" + { PGAStar *star = makeNode(PGAStar); - star->except_list = (yyvsp[-1].list); - star->replace_list = (yyvsp[0].list); - star->location = (yylsp[-2]); + star->except_list = (yyvsp[(2) - (3)].list); + star->replace_list = (yyvsp[(3) - (3)].list); + star->location = (yylsp[(1) - (3)]); (yyval.node) = (PGNode *) star; - } -#line 26736 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 969: /* a_expr: ColId '.' '*' opt_except_list opt_replace_list */ -#line 2563 "third_party/libpg_query/grammar/statements/select.y" - { + case 971: +#line 2574 "third_party/libpg_query/grammar/statements/select.y" + { PGAStar *star = makeNode(PGAStar); - star->relation = (yyvsp[-4].str); - star->except_list = (yyvsp[-1].list); - star->replace_list = (yyvsp[0].list); - star->location = (yylsp[-4]); + star->relation = (yyvsp[(1) - (5)].str); + star->except_list = (yyvsp[(4) - (5)].list); + star->replace_list = (yyvsp[(5) - (5)].list); + star->location = (yylsp[(1) - (5)]); (yyval.node) = (PGNode *) star; - } -#line 26749 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 970: /* b_expr: c_expr */ -#line 2583 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 26755 "third_party/libpg_query/grammar/grammar_out.cpp" + case 972: +#line 2594 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 971: /* b_expr: b_expr TYPECAST Typename */ -#line 2585 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeTypeCast((yyvsp[-2].node), (yyvsp[0].typnam), 0, (yylsp[-1])); } -#line 26761 "third_party/libpg_query/grammar/grammar_out.cpp" + case 973: +#line 2596 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), 0, (yylsp[(2) - (3)])); ;} break; - case 972: /* b_expr: '+' b_expr */ -#line 2587 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[0].node), (yylsp[-1])); } -#line 26767 "third_party/libpg_query/grammar/grammar_out.cpp" + case 974: +#line 2598 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 973: /* b_expr: '-' b_expr */ -#line 2589 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = doNegate((yyvsp[0].node), (yylsp[-1])); } -#line 26773 "third_party/libpg_query/grammar/grammar_out.cpp" + case 975: +#line 2600 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 974: /* b_expr: b_expr '+' b_expr */ -#line 2591 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26779 "third_party/libpg_query/grammar/grammar_out.cpp" + case 976: +#line 2602 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 975: /* b_expr: b_expr '-' b_expr */ -#line 2593 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26785 "third_party/libpg_query/grammar/grammar_out.cpp" + case 977: +#line 2604 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 976: /* b_expr: b_expr '*' b_expr */ -#line 2595 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "*", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26791 "third_party/libpg_query/grammar/grammar_out.cpp" + case 978: +#line 2606 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "*", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 977: /* b_expr: b_expr '/' b_expr */ -#line 2597 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "/", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26797 "third_party/libpg_query/grammar/grammar_out.cpp" + case 979: +#line 2608 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "/", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 978: /* b_expr: b_expr INTEGER_DIVISION b_expr */ -#line 2599 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "//", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26803 "third_party/libpg_query/grammar/grammar_out.cpp" + case 980: +#line 2610 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "//", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 979: /* b_expr: b_expr '%' b_expr */ -#line 2601 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "%", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26809 "third_party/libpg_query/grammar/grammar_out.cpp" + case 981: +#line 2612 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "%", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 980: /* b_expr: b_expr '^' b_expr */ -#line 2603 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26815 "third_party/libpg_query/grammar/grammar_out.cpp" + case 982: +#line 2614 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 981: /* b_expr: b_expr POWER_OF b_expr */ -#line 2605 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26821 "third_party/libpg_query/grammar/grammar_out.cpp" + case 983: +#line 2616 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 982: /* b_expr: b_expr '<' b_expr */ -#line 2607 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26827 "third_party/libpg_query/grammar/grammar_out.cpp" + case 984: +#line 2618 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 983: /* b_expr: b_expr '>' b_expr */ -#line 2609 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26833 "third_party/libpg_query/grammar/grammar_out.cpp" + case 985: +#line 2620 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 984: /* b_expr: b_expr '=' b_expr */ -#line 2611 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26839 "third_party/libpg_query/grammar/grammar_out.cpp" + case 986: +#line 2622 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 985: /* b_expr: b_expr LESS_EQUALS b_expr */ -#line 2613 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26845 "third_party/libpg_query/grammar/grammar_out.cpp" + case 987: +#line 2624 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 986: /* b_expr: b_expr GREATER_EQUALS b_expr */ -#line 2615 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26851 "third_party/libpg_query/grammar/grammar_out.cpp" + case 988: +#line 2626 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 987: /* b_expr: b_expr NOT_EQUALS b_expr */ -#line 2617 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26857 "third_party/libpg_query/grammar/grammar_out.cpp" + case 989: +#line 2628 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 988: /* b_expr: b_expr qual_Op b_expr */ -#line 2619 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[-1].list), (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26863 "third_party/libpg_query/grammar/grammar_out.cpp" + case 990: +#line 2630 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 989: /* b_expr: qual_Op b_expr */ -#line 2621 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[-1].list), NULL, (yyvsp[0].node), (yylsp[-1])); } -#line 26869 "third_party/libpg_query/grammar/grammar_out.cpp" + case 991: +#line 2632 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 990: /* b_expr: b_expr qual_Op */ -#line 2623 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[0].list), (yyvsp[-1].node), NULL, (yylsp[0])); } -#line 26875 "third_party/libpg_query/grammar/grammar_out.cpp" + case 992: +#line 2634 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;} break; - case 991: /* b_expr: b_expr IS DISTINCT FROM b_expr */ -#line 2625 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[-4].node), (yyvsp[0].node), (yylsp[-3])); - } -#line 26883 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 992: /* b_expr: b_expr IS NOT DISTINCT FROM b_expr */ -#line 2629 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[-5].node), (yyvsp[0].node), (yylsp[-4])); - } -#line 26891 "third_party/libpg_query/grammar/grammar_out.cpp" + case 993: +#line 2636 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)])); + ;} break; - case 993: /* b_expr: b_expr IS OF '(' type_list ')' */ -#line 2633 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[-5].node), (PGNode *) (yyvsp[-1].list), (yylsp[-4])); - } -#line 26899 "third_party/libpg_query/grammar/grammar_out.cpp" + case 994: +#line 2640 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[(1) - (6)].node), (yyvsp[(6) - (6)].node), (yylsp[(2) - (6)])); + ;} break; - case 994: /* b_expr: b_expr IS NOT OF '(' type_list ')' */ -#line 2637 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[-6].node), (PGNode *) (yyvsp[-1].list), (yylsp[-5])); - } -#line 26907 "third_party/libpg_query/grammar/grammar_out.cpp" + case 995: +#line 2644 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (PGNode *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)])); + ;} break; - case 996: /* c_expr: row */ -#line 2651 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = makeFuncCall(SystemFuncName("row"), (yyvsp[0].list), (yylsp[0])); - (yyval.node) = (PGNode *) n; - } -#line 26916 "third_party/libpg_query/grammar/grammar_out.cpp" + case 996: +#line 2648 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (PGNode *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)])); + ;} break; - case 997: /* c_expr: indirection_expr opt_extended_indirection */ -#line 2656 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].list)) + case 998: +#line 2663 "third_party/libpg_query/grammar/statements/select.y" + { + if ((yyvsp[(2) - (2)].list)) { PGAIndirection *n = makeNode(PGAIndirection); - n->arg = (PGNode *) (yyvsp[-1].node); - n->indirection = check_indirection((yyvsp[0].list), yyscanner); + n->arg = (PGNode *) (yyvsp[(1) - (2)].node); + n->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner); (yyval.node) = (PGNode *) n; } else - (yyval.node) = (PGNode *) (yyvsp[-1].node); - } -#line 26932 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) (yyvsp[(1) - (2)].node); + ;} break; - case 998: /* d_expr: columnref */ -#line 2669 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 26938 "third_party/libpg_query/grammar/grammar_out.cpp" + case 999: +#line 2676 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 999: /* d_expr: AexprConst */ -#line 2670 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 26944 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1000: +#line 2677 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1000: /* d_expr: '#' ICONST */ -#line 2672 "third_party/libpg_query/grammar/statements/select.y" - { - PGPositionalReference *n = makeNode(PGPositionalReference); - n->position = (yyvsp[0].ival); - n->location = (yylsp[-1]); - (yyval.node) = (PGNode *) n; - } -#line 26955 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 1001: /* d_expr: '$' ColLabel */ + case 1001: #line 2679 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeNamedParamRef((yyvsp[0].str), (yylsp[-1])); - } -#line 26963 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 1002: /* d_expr: '[' opt_expr_list_opt_comma ']' */ -#line 2682 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = makeFuncCall(SystemFuncName("list_value"), (yyvsp[-1].list), (yylsp[-1])); - (yyval.node) = (PGNode *) n; - } -#line 26972 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 1003: /* d_expr: list_comprehension */ -#line 2686 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 26980 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 1004: /* d_expr: ARRAY select_with_parens */ -#line 2690 "third_party/libpg_query/grammar/statements/select.y" - { - PGSubLink *n = makeNode(PGSubLink); - n->subLinkType = PG_ARRAY_SUBLINK; - n->subLinkId = 0; - n->testexpr = NULL; - n->operName = NULL; - n->subselect = (yyvsp[0].node); - n->location = (yylsp[0]); - (yyval.node) = (PGNode *)n; - } -#line 26995 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 1005: /* d_expr: ARRAY '[' opt_expr_list_opt_comma ']' */ -#line 2700 "third_party/libpg_query/grammar/statements/select.y" - { - PGList *func_name = list_make1(makeString("construct_array")); - PGFuncCall *n = makeFuncCall(func_name, (yyvsp[-1].list), (yylsp[-3])); - (yyval.node) = (PGNode *) n; - } -#line 27005 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 1006: /* d_expr: case_expr */ -#line 2706 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 27011 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 1007: /* d_expr: select_with_parens */ -#line 2708 "third_party/libpg_query/grammar/statements/select.y" - { + { PGSubLink *n = makeNode(PGSubLink); n->subLinkType = PG_EXPR_SUBLINK; n->subLinkId = 0; n->testexpr = NULL; n->operName = NIL; - n->subselect = (yyvsp[0].node); - n->location = (yylsp[0]); + n->subselect = (yyvsp[(1) - (1)].node); + n->location = (yylsp[(1) - (1)]); (yyval.node) = (PGNode *)n; - } -#line 27026 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1008: /* d_expr: select_with_parens indirection */ -#line 2719 "third_party/libpg_query/grammar/statements/select.y" - { + case 1002: +#line 2690 "third_party/libpg_query/grammar/statements/select.y" + { /* * Because the select_with_parens nonterminal is designed * to "eat" as many levels of parens as possible, the @@ -413560,188 +417136,247 @@ YYLTYPE yylloc = yyloc_default; n->subLinkId = 0; n->testexpr = NULL; n->operName = NIL; - n->subselect = (yyvsp[-1].node); - n->location = (yylsp[-1]); + n->subselect = (yyvsp[(1) - (2)].node); + n->location = (yylsp[(1) - (2)]); a->arg = (PGNode *)n; - a->indirection = check_indirection((yyvsp[0].list), yyscanner); + a->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner); (yyval.node) = (PGNode *)a; - } -#line 27054 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1009: /* d_expr: EXISTS select_with_parens */ -#line 2743 "third_party/libpg_query/grammar/statements/select.y" - { + case 1003: +#line 2714 "third_party/libpg_query/grammar/statements/select.y" + { PGSubLink *n = makeNode(PGSubLink); n->subLinkType = PG_EXISTS_SUBLINK; n->subLinkId = 0; n->testexpr = NULL; n->operName = NIL; - n->subselect = (yyvsp[0].node); - n->location = (yylsp[-1]); + n->subselect = (yyvsp[(2) - (2)].node); + n->location = (yylsp[(1) - (2)]); (yyval.node) = (PGNode *)n; - } -#line 27069 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1010: /* d_expr: grouping_or_grouping_id '(' expr_list_opt_comma ')' */ -#line 2754 "third_party/libpg_query/grammar/statements/select.y" - { + case 1004: +#line 2725 "third_party/libpg_query/grammar/statements/select.y" + { PGGroupingFunc *g = makeNode(PGGroupingFunc); - g->args = (yyvsp[-1].list); - g->location = (yylsp[-3]); + g->args = (yyvsp[(3) - (4)].list); + g->location = (yylsp[(1) - (4)]); (yyval.node) = (PGNode *)g; - } -#line 27080 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1011: /* indirection_expr: '?' */ -#line 2765 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeParamRef(0, (yylsp[0])); - } -#line 27088 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1005: +#line 2735 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (yyvsp[(2) - (3)].node); + ;} break; - case 1012: /* indirection_expr: PARAM */ -#line 2769 "third_party/libpg_query/grammar/statements/select.y" - { - PGParamRef *p = makeNode(PGParamRef); - p->number = (yyvsp[0].ival); - p->location = (yylsp[0]); - (yyval.node) = (PGNode *) p; - } -#line 27099 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1006: +#line 2739 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 1013: /* indirection_expr: '(' a_expr ')' */ -#line 2776 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[-1].node); - } -#line 27107 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1007: +#line 2742 "third_party/libpg_query/grammar/statements/select.y" + { + PGFuncCall *n = makeFuncCall(SystemFuncName("row"), (yyvsp[(1) - (1)].list), (yylsp[(1) - (1)])); + (yyval.node) = (PGNode *) n; + ;} break; - case 1014: /* indirection_expr: struct_expr */ -#line 2780 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 27115 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1008: +#line 2750 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeParamRef(0, (yylsp[(1) - (1)])); + ;} + break; + + case 1009: +#line 2754 "third_party/libpg_query/grammar/statements/select.y" + { + PGParamRef *p = makeNode(PGParamRef); + p->number = (yyvsp[(1) - (1)].ival); + p->location = (yylsp[(1) - (1)]); + (yyval.node) = (PGNode *) p; + ;} break; - case 1015: /* indirection_expr: MAP '{' opt_map_arguments_opt_comma '}' */ -#line 2784 "third_party/libpg_query/grammar/statements/select.y" - { + case 1010: +#line 2761 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} + break; + + case 1011: +#line 2765 "third_party/libpg_query/grammar/statements/select.y" + { PGList *key_list = NULL; PGList *value_list = NULL; PGListCell *lc; - PGList *entry_list = (yyvsp[-1].list); + PGList *entry_list = (yyvsp[(3) - (4)].list); foreach(lc, entry_list) { PGList *l = (PGList *) lc->data.ptr_value; key_list = lappend(key_list, (PGNode *) l->head->data.ptr_value); value_list = lappend(value_list, (PGNode *) l->tail->data.ptr_value); } - PGNode *keys = (PGNode *) makeFuncCall(SystemFuncName("list_value"), key_list, (yylsp[-1])); - PGNode *values = (PGNode *) makeFuncCall(SystemFuncName("list_value"), value_list, (yylsp[-1])); - PGFuncCall *f = makeFuncCall(SystemFuncName("map"), list_make2(keys, values), (yylsp[-1])); + PGNode *keys = (PGNode *) makeFuncCall(SystemFuncName("list_value"), key_list, (yylsp[(3) - (4)])); + PGNode *values = (PGNode *) makeFuncCall(SystemFuncName("list_value"), value_list, (yylsp[(3) - (4)])); + PGFuncCall *f = makeFuncCall(SystemFuncName("map"), list_make2(keys, values), (yylsp[(3) - (4)])); (yyval.node) = (PGNode *) f; - } -#line 27136 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1016: /* indirection_expr: func_expr */ -#line 2801 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 27144 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1012: +#line 2782 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 1017: /* struct_expr: '{' dict_arguments_opt_comma '}' */ -#line 2809 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *f = makeFuncCall(SystemFuncName("struct_pack"), (yyvsp[-1].list), (yylsp[-1])); - (yyval.node) = (PGNode *) f; - } -#line 27153 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1013: +#line 2786 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} + break; + + case 1014: +#line 2787 "third_party/libpg_query/grammar/statements/select.y" + { + PGFuncCall *n = makeFuncCall(SystemFuncName("list_value"), (yyvsp[(2) - (3)].list), (yylsp[(2) - (3)])); + (yyval.node) = (PGNode *) n; + ;} + break; + + case 1015: +#line 2791 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 1018: /* func_application: func_name '(' ')' */ + case 1016: +#line 2795 "third_party/libpg_query/grammar/statements/select.y" + { + PGSubLink *n = makeNode(PGSubLink); + n->subLinkType = PG_ARRAY_SUBLINK; + n->subLinkId = 0; + n->testexpr = NULL; + n->operName = NULL; + n->subselect = (yyvsp[(2) - (2)].node); + n->location = (yylsp[(2) - (2)]); + (yyval.node) = (PGNode *)n; + ;} + break; + + case 1017: +#line 2805 "third_party/libpg_query/grammar/statements/select.y" + { + PGList *func_name = list_make1(makeString("construct_array")); + PGFuncCall *n = makeFuncCall(func_name, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + (yyval.node) = (PGNode *) n; + ;} + break; + + case 1018: +#line 2811 "third_party/libpg_query/grammar/statements/select.y" + { + PGPositionalReference *n = makeNode(PGPositionalReference); + n->position = (yyvsp[(2) - (2)].ival); + n->location = (yylsp[(1) - (2)]); + (yyval.node) = (PGNode *) n; + ;} + break; + + case 1019: #line 2818 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeFuncCall((yyvsp[-2].list), NIL, (yylsp[-2])); - } -#line 27161 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeNamedParamRef((yyvsp[(2) - (2)].str), (yylsp[(1) - (2)])); + ;} + break; + + case 1020: +#line 2826 "third_party/libpg_query/grammar/statements/select.y" + { + PGFuncCall *f = makeFuncCall(SystemFuncName("struct_pack"), (yyvsp[(2) - (3)].list), (yylsp[(2) - (3)])); + (yyval.node) = (PGNode *) f; + ;} + break; + + case 1021: +#line 2835 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeFuncCall((yyvsp[(1) - (3)].list), NIL, (yylsp[(1) - (3)])); + ;} break; - case 1019: /* func_application: func_name '(' func_arg_list opt_sort_clause opt_ignore_nulls ')' */ -#line 2822 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = makeFuncCall((yyvsp[-5].list), (yyvsp[-3].list), (yylsp[-5])); - n->agg_order = (yyvsp[-2].list); - n->agg_ignore_nulls = (yyvsp[-1].boolean); + case 1022: +#line 2839 "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); + n->agg_ignore_nulls = (yyvsp[(5) - (6)].boolean); (yyval.node) = (PGNode *)n; - } -#line 27172 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1020: /* func_application: func_name '(' VARIADIC func_arg_expr opt_sort_clause opt_ignore_nulls ')' */ -#line 2829 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = makeFuncCall((yyvsp[-6].list), list_make1((yyvsp[-3].node)), (yylsp[-6])); + case 1023: +#line 2846 "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; - n->agg_order = (yyvsp[-2].list); - n->agg_ignore_nulls = (yyvsp[-1].boolean); + n->agg_order = (yyvsp[(5) - (7)].list); + n->agg_ignore_nulls = (yyvsp[(6) - (7)].boolean); (yyval.node) = (PGNode *)n; - } -#line 27184 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1021: /* func_application: func_name '(' func_arg_list ',' VARIADIC func_arg_expr opt_sort_clause opt_ignore_nulls ')' */ -#line 2837 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = makeFuncCall((yyvsp[-8].list), lappend((yyvsp[-6].list), (yyvsp[-3].node)), (yylsp[-8])); + case 1024: +#line 2854 "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; - n->agg_order = (yyvsp[-2].list); - n->agg_ignore_nulls = (yyvsp[-1].boolean); + n->agg_order = (yyvsp[(7) - (9)].list); + n->agg_ignore_nulls = (yyvsp[(8) - (9)].boolean); (yyval.node) = (PGNode *)n; - } -#line 27196 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1022: /* func_application: func_name '(' ALL func_arg_list opt_sort_clause opt_ignore_nulls ')' */ -#line 2845 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = makeFuncCall((yyvsp[-6].list), (yyvsp[-3].list), (yylsp[-6])); - n->agg_order = (yyvsp[-2].list); - n->agg_ignore_nulls = (yyvsp[-1].boolean); + case 1025: +#line 2862 "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); + n->agg_ignore_nulls = (yyvsp[(6) - (7)].boolean); /* Ideally we'd mark the PGFuncCall node to indicate * "must be an aggregate", but there's no provision * for that in PGFuncCall at the moment. */ (yyval.node) = (PGNode *)n; - } -#line 27211 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1023: /* func_application: func_name '(' DISTINCT func_arg_list opt_sort_clause opt_ignore_nulls ')' */ -#line 2856 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = makeFuncCall((yyvsp[-6].list), (yyvsp[-3].list), (yylsp[-6])); - n->agg_order = (yyvsp[-2].list); - n->agg_ignore_nulls = (yyvsp[-1].boolean); + case 1026: +#line 2873 "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); + n->agg_ignore_nulls = (yyvsp[(6) - (7)].boolean); n->agg_distinct = true; (yyval.node) = (PGNode *)n; - } -#line 27223 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1024: /* func_expr: func_application within_group_clause filter_clause export_clause over_clause */ -#line 2876 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = (PGFuncCall *) (yyvsp[-4].node); + case 1027: +#line 2893 "third_party/libpg_query/grammar/statements/select.y" + { + PGFuncCall *n = (PGFuncCall *) (yyvsp[(1) - (5)].node); /* * The order clause for WITHIN GROUP and the one for * plain-aggregate ORDER BY share a field, so we have to @@ -413750,118 +417385,107 @@ YYLTYPE yylloc = yyloc_default; * location. Other consistency checks are deferred to * parse analysis. */ - if ((yyvsp[-3].list) != NIL) + if ((yyvsp[(2) - (5)].list) != NIL) { if (n->agg_order != NIL) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("cannot use multiple ORDER BY clauses with WITHIN GROUP"), - parser_errposition((yylsp[-3])))); + parser_errposition((yylsp[(2) - (5)])))); if (n->agg_distinct) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("cannot use DISTINCT with WITHIN GROUP"), - parser_errposition((yylsp[-3])))); + parser_errposition((yylsp[(2) - (5)])))); if (n->func_variadic) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("cannot use VARIADIC with WITHIN GROUP"), - parser_errposition((yylsp[-3])))); - n->agg_order = (yyvsp[-3].list); + parser_errposition((yylsp[(2) - (5)])))); + n->agg_order = (yyvsp[(2) - (5)].list); n->agg_within_group = true; } - n->agg_filter = (yyvsp[-2].node); - n->export_state = (yyvsp[-1].boolean); - n->over = (yyvsp[0].windef); + n->agg_filter = (yyvsp[(3) - (5)].node); + n->export_state = (yyvsp[(4) - (5)].boolean); + n->over = (yyvsp[(5) - (5)].windef); (yyval.node) = (PGNode *) n; - } -#line 27263 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1025: /* func_expr: func_expr_common_subexpr */ -#line 2912 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 27269 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1028: +#line 2929 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1026: /* func_expr_windowless: func_application */ -#line 2922 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 27275 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1029: +#line 2939 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1027: /* func_expr_windowless: func_expr_common_subexpr */ -#line 2923 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 27281 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1030: +#line 2940 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1028: /* func_expr_common_subexpr: COLLATION FOR '(' a_expr ')' */ -#line 2931 "third_party/libpg_query/grammar/statements/select.y" - { + case 1031: +#line 2948 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("pg_collation_for"), - list_make1((yyvsp[-1].node)), - (yylsp[-4])); - } -#line 27291 "third_party/libpg_query/grammar/grammar_out.cpp" + list_make1((yyvsp[(4) - (5)].node)), + (yylsp[(1) - (5)])); + ;} break; - case 1029: /* func_expr_common_subexpr: CAST '(' a_expr AS Typename ')' */ -#line 2937 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeTypeCast((yyvsp[-3].node), (yyvsp[-1].typnam), 0, (yylsp[-5])); } -#line 27297 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1032: +#line 2954 "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 1030: /* func_expr_common_subexpr: TRY_CAST '(' a_expr AS Typename ')' */ -#line 2939 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeTypeCast((yyvsp[-3].node), (yyvsp[-1].typnam), 1, (yylsp[-5])); } -#line 27303 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1033: +#line 2956 "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 1031: /* func_expr_common_subexpr: EXTRACT '(' extract_list ')' */ -#line 2941 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("date_part"), (yyvsp[-1].list), (yylsp[-3])); - } -#line 27311 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1034: +#line 2958 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("date_part"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 1032: /* func_expr_common_subexpr: OVERLAY '(' overlay_list ')' */ -#line 2945 "third_party/libpg_query/grammar/statements/select.y" - { + case 1035: +#line 2962 "third_party/libpg_query/grammar/statements/select.y" + { /* overlay(A PLACING B FROM C FOR D) is converted to * overlay(A, B, C, D) * overlay(A PLACING B FROM C) is converted to * overlay(A, B, C) */ - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("overlay"), (yyvsp[-1].list), (yylsp[-3])); - } -#line 27324 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("overlay"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 1033: /* func_expr_common_subexpr: POSITION '(' position_list ')' */ -#line 2954 "third_party/libpg_query/grammar/statements/select.y" - { + case 1036: +#line 2971 "third_party/libpg_query/grammar/statements/select.y" + { /* position(A in B) is converted to position(B, A) */ - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("position"), (yyvsp[-1].list), (yylsp[-3])); - } -#line 27333 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("position"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 1034: /* func_expr_common_subexpr: SUBSTRING '(' substr_list ')' */ -#line 2959 "third_party/libpg_query/grammar/statements/select.y" - { + case 1037: +#line 2976 "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 */ - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("substring"), (yyvsp[-1].list), (yylsp[-3])); - } -#line 27344 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("substring"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 1035: /* func_expr_common_subexpr: TREAT '(' a_expr AS Typename ')' */ -#line 2966 "third_party/libpg_query/grammar/statements/select.y" - { + case 1038: +#line 2983 "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. * In SQL99, this is intended for use with structured UDTs, @@ -413871,322 +417495,288 @@ YYLTYPE yylloc = yyloc_default; * Convert SystemTypeName() to SystemFuncName() even though * at the moment they result in the same thing. */ - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName(((PGValue *)llast((yyvsp[-1].typnam)->names))->val.str), - list_make1((yyvsp[-3].node)), - (yylsp[-5])); - } -#line 27363 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName(((PGValue *)llast((yyvsp[(5) - (6)].typnam)->names))->val.str), + list_make1((yyvsp[(3) - (6)].node)), + (yylsp[(1) - (6)])); + ;} break; - case 1036: /* func_expr_common_subexpr: TRIM '(' BOTH trim_list ')' */ -#line 2981 "third_party/libpg_query/grammar/statements/select.y" - { + case 1039: +#line 2998 "third_party/libpg_query/grammar/statements/select.y" + { /* various trim expressions are defined in SQL * - thomas 1997-07-19 */ - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[-1].list), (yylsp[-4])); - } -#line 27374 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); + ;} break; - case 1037: /* func_expr_common_subexpr: TRIM '(' LEADING trim_list ')' */ -#line 2988 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("ltrim"), (yyvsp[-1].list), (yylsp[-4])); - } -#line 27382 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1040: +#line 3005 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("ltrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); + ;} break; - case 1038: /* func_expr_common_subexpr: TRIM '(' TRAILING trim_list ')' */ -#line 2992 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("rtrim"), (yyvsp[-1].list), (yylsp[-4])); - } -#line 27390 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1041: +#line 3009 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("rtrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); + ;} break; - case 1039: /* func_expr_common_subexpr: TRIM '(' trim_list ')' */ -#line 2996 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[-1].list), (yylsp[-3])); - } -#line 27398 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1042: +#line 3013 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 1040: /* func_expr_common_subexpr: NULLIF '(' a_expr ',' a_expr ')' */ -#line 3000 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NULLIF, "=", (yyvsp[-3].node), (yyvsp[-1].node), (yylsp[-5])); - } -#line 27406 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1043: +#line 3017 "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 1041: /* func_expr_common_subexpr: COALESCE '(' expr_list_opt_comma ')' */ -#line 3004 "third_party/libpg_query/grammar/statements/select.y" - { + case 1044: +#line 3021 "third_party/libpg_query/grammar/statements/select.y" + { PGCoalesceExpr *c = makeNode(PGCoalesceExpr); - c->args = (yyvsp[-1].list); - c->location = (yylsp[-3]); + c->args = (yyvsp[(3) - (4)].list); + c->location = (yylsp[(1) - (4)]); (yyval.node) = (PGNode *)c; - } -#line 27417 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1042: /* list_comprehension: '[' a_expr FOR ColId IN_P a_expr ']' */ -#line 3014 "third_party/libpg_query/grammar/statements/select.y" - { + case 1045: +#line 3031 "third_party/libpg_query/grammar/statements/select.y" + { PGLambdaFunction *lambda = makeNode(PGLambdaFunction); - lambda->lhs = makeColumnRef((yyvsp[-3].str), NIL, (yylsp[-3]), yyscanner); - lambda->rhs = (yyvsp[-5].node); - lambda->location = (yylsp[-6]); - PGFuncCall *n = makeFuncCall(SystemFuncName("list_apply"), list_make2((yyvsp[-1].node), lambda), (yylsp[-6])); + lambda->lhs = makeColumnRef((yyvsp[(4) - (7)].str), NIL, (yylsp[(4) - (7)]), yyscanner); + lambda->rhs = (yyvsp[(2) - (7)].node); + lambda->location = (yylsp[(1) - (7)]); + PGFuncCall *n = makeFuncCall(SystemFuncName("list_apply"), list_make2((yyvsp[(6) - (7)].node), lambda), (yylsp[(1) - (7)])); (yyval.node) = (PGNode *) n; - } -#line 27430 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1043: /* list_comprehension: '[' a_expr FOR ColId IN_P c_expr IF_P a_expr ']' */ -#line 3023 "third_party/libpg_query/grammar/statements/select.y" - { + case 1046: +#line 3040 "third_party/libpg_query/grammar/statements/select.y" + { PGLambdaFunction *lambda = makeNode(PGLambdaFunction); - lambda->lhs = makeColumnRef((yyvsp[-5].str), NIL, (yylsp[-5]), yyscanner); - lambda->rhs = (yyvsp[-7].node); - lambda->location = (yylsp[-8]); + lambda->lhs = makeColumnRef((yyvsp[(4) - (9)].str), NIL, (yylsp[(4) - (9)]), yyscanner); + lambda->rhs = (yyvsp[(2) - (9)].node); + lambda->location = (yylsp[(1) - (9)]); PGLambdaFunction *lambda_filter = makeNode(PGLambdaFunction); - lambda_filter->lhs = makeColumnRef((yyvsp[-5].str), NIL, (yylsp[-5]), yyscanner); - lambda_filter->rhs = (yyvsp[-1].node); - lambda_filter->location = (yylsp[-1]); - PGFuncCall *filter = makeFuncCall(SystemFuncName("list_filter"), list_make2((yyvsp[-3].node), lambda_filter), (yylsp[-8])); - PGFuncCall *n = makeFuncCall(SystemFuncName("list_apply"), list_make2(filter, lambda), (yylsp[-8])); + lambda_filter->lhs = makeColumnRef((yyvsp[(4) - (9)].str), NIL, (yylsp[(4) - (9)]), yyscanner); + lambda_filter->rhs = (yyvsp[(8) - (9)].node); + lambda_filter->location = (yylsp[(8) - (9)]); + PGFuncCall *filter = makeFuncCall(SystemFuncName("list_filter"), list_make2((yyvsp[(6) - (9)].node), lambda_filter), (yylsp[(1) - (9)])); + PGFuncCall *n = makeFuncCall(SystemFuncName("list_apply"), list_make2(filter, lambda), (yylsp[(1) - (9)])); (yyval.node) = (PGNode *) n; - } -#line 27449 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1044: /* within_group_clause: WITHIN GROUP_P '(' sort_clause ')' */ -#line 3044 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 27455 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1047: +#line 3061 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(4) - (5)].list); ;} break; - case 1045: /* within_group_clause: %empty */ -#line 3045 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 27461 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1048: +#line 3062 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 1046: /* filter_clause: FILTER '(' WHERE a_expr ')' */ -#line 3049 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 27467 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1049: +#line 3066 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(4) - (5)].node); ;} break; - case 1047: /* filter_clause: FILTER '(' a_expr ')' */ -#line 3050 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 27473 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1050: +#line 3067 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(3) - (4)].node); ;} break; - case 1048: /* filter_clause: %empty */ -#line 3051 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 27479 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1051: +#line 3068 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 1049: /* export_clause: EXPORT_STATE */ -#line 3055 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 27485 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1052: +#line 3072 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = true; ;} break; - case 1050: /* export_clause: %empty */ -#line 3056 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 27491 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1053: +#line 3073 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.boolean) = false; ;} break; - case 1051: /* window_clause: WINDOW window_definition_list */ -#line 3063 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 27497 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1054: +#line 3080 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1052: /* window_clause: %empty */ -#line 3064 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 27503 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1055: +#line 3081 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 1053: /* window_definition_list: window_definition */ -#line 3068 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].windef)); } -#line 27509 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1056: +#line 3085 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].windef)); ;} break; - case 1054: /* window_definition_list: window_definition_list ',' window_definition */ -#line 3070 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].windef)); } -#line 27515 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1057: +#line 3087 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].windef)); ;} break; - case 1055: /* window_definition: ColId AS window_specification */ -#line 3075 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n = (yyvsp[0].windef); - n->name = (yyvsp[-2].str); + case 1058: +#line 3092 "third_party/libpg_query/grammar/statements/select.y" + { + PGWindowDef *n = (yyvsp[(3) - (3)].windef); + n->name = (yyvsp[(1) - (3)].str); (yyval.windef) = n; - } -#line 27525 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1056: /* over_clause: OVER window_specification */ -#line 3083 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.windef) = (yyvsp[0].windef); } -#line 27531 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1059: +#line 3100 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.windef) = (yyvsp[(2) - (2)].windef); ;} break; - case 1057: /* over_clause: OVER ColId */ -#line 3085 "third_party/libpg_query/grammar/statements/select.y" - { + case 1060: +#line 3102 "third_party/libpg_query/grammar/statements/select.y" + { PGWindowDef *n = makeNode(PGWindowDef); - n->name = (yyvsp[0].str); + n->name = (yyvsp[(2) - (2)].str); n->refname = NULL; n->partitionClause = NIL; n->orderClause = NIL; n->frameOptions = FRAMEOPTION_DEFAULTS; n->startOffset = NULL; n->endOffset = NULL; - n->location = (yylsp[0]); + n->location = (yylsp[(2) - (2)]); (yyval.windef) = n; - } -#line 27548 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1058: /* over_clause: %empty */ -#line 3098 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.windef) = NULL; } -#line 27554 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1061: +#line 3115 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.windef) = NULL; ;} break; - case 1059: /* window_specification: '(' opt_existing_window_name opt_partition_clause opt_sort_clause opt_frame_clause ')' */ -#line 3103 "third_party/libpg_query/grammar/statements/select.y" - { + case 1062: +#line 3120 "third_party/libpg_query/grammar/statements/select.y" + { PGWindowDef *n = makeNode(PGWindowDef); n->name = NULL; - n->refname = (yyvsp[-4].str); - n->partitionClause = (yyvsp[-3].list); - n->orderClause = (yyvsp[-2].list); + n->refname = (yyvsp[(2) - (6)].str); + n->partitionClause = (yyvsp[(3) - (6)].list); + n->orderClause = (yyvsp[(4) - (6)].list); /* copy relevant fields of opt_frame_clause */ - n->frameOptions = (yyvsp[-1].windef)->frameOptions; - n->startOffset = (yyvsp[-1].windef)->startOffset; - n->endOffset = (yyvsp[-1].windef)->endOffset; - n->location = (yylsp[-5]); + n->frameOptions = (yyvsp[(5) - (6)].windef)->frameOptions; + n->startOffset = (yyvsp[(5) - (6)].windef)->startOffset; + n->endOffset = (yyvsp[(5) - (6)].windef)->endOffset; + n->location = (yylsp[(1) - (6)]); (yyval.windef) = n; - } -#line 27572 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1060: /* opt_existing_window_name: ColId */ -#line 3128 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 27578 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1063: +#line 3145 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1061: /* opt_existing_window_name: %empty */ -#line 3129 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = NULL; } -#line 27584 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1064: +#line 3146 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = NULL; ;} break; - case 1062: /* opt_partition_clause: PARTITION BY expr_list */ -#line 3132 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 27590 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1065: +#line 3149 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 1063: /* opt_partition_clause: %empty */ -#line 3133 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 27596 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1066: +#line 3150 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 1064: /* opt_frame_clause: RANGE frame_extent opt_window_exclusion_clause */ -#line 3142 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n = (yyvsp[-1].windef); + case 1067: +#line 3159 "third_party/libpg_query/grammar/statements/select.y" + { + PGWindowDef *n = (yyvsp[(2) - (3)].windef); n->frameOptions |= FRAMEOPTION_NONDEFAULT | FRAMEOPTION_RANGE; - n->frameOptions |= (yyvsp[0].ival); + n->frameOptions |= (yyvsp[(3) - (3)].ival); (yyval.windef) = n; - } -#line 27608 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1065: /* opt_frame_clause: ROWS frame_extent opt_window_exclusion_clause */ -#line 3150 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n = (yyvsp[-1].windef); + case 1068: +#line 3167 "third_party/libpg_query/grammar/statements/select.y" + { + PGWindowDef *n = (yyvsp[(2) - (3)].windef); n->frameOptions |= FRAMEOPTION_NONDEFAULT | FRAMEOPTION_ROWS; - n->frameOptions |= (yyvsp[0].ival); + n->frameOptions |= (yyvsp[(3) - (3)].ival); (yyval.windef) = n; - } -#line 27620 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1066: /* opt_frame_clause: GROUPS frame_extent opt_window_exclusion_clause */ -#line 3158 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n = (yyvsp[-1].windef); + case 1069: +#line 3175 "third_party/libpg_query/grammar/statements/select.y" + { + PGWindowDef *n = (yyvsp[(2) - (3)].windef); n->frameOptions |= FRAMEOPTION_NONDEFAULT | FRAMEOPTION_GROUPS; - n->frameOptions |= (yyvsp[0].ival); + n->frameOptions |= (yyvsp[(3) - (3)].ival); (yyval.windef) = n; - } -#line 27632 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1067: /* opt_frame_clause: %empty */ -#line 3166 "third_party/libpg_query/grammar/statements/select.y" - { + case 1070: +#line 3183 "third_party/libpg_query/grammar/statements/select.y" + { PGWindowDef *n = makeNode(PGWindowDef); n->frameOptions = FRAMEOPTION_DEFAULTS; n->startOffset = NULL; n->endOffset = NULL; (yyval.windef) = n; - } -#line 27645 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1068: /* frame_extent: frame_bound */ -#line 3177 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n = (yyvsp[0].windef); + case 1071: +#line 3194 "third_party/libpg_query/grammar/statements/select.y" + { + PGWindowDef *n = (yyvsp[(1) - (1)].windef); /* reject invalid cases */ if (n->frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING) ereport(ERROR, (errcode(PG_ERRCODE_WINDOWING_ERROR), errmsg("frame start cannot be UNBOUNDED FOLLOWING"), - parser_errposition((yylsp[0])))); + parser_errposition((yylsp[(1) - (1)])))); if (n->frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING) ereport(ERROR, (errcode(PG_ERRCODE_WINDOWING_ERROR), errmsg("frame starting from following row cannot end with current row"), - parser_errposition((yylsp[0])))); + parser_errposition((yylsp[(1) - (1)])))); n->frameOptions |= FRAMEOPTION_END_CURRENT_ROW; (yyval.windef) = n; - } -#line 27667 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1069: /* frame_extent: BETWEEN frame_bound AND frame_bound */ -#line 3195 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n1 = (yyvsp[-2].windef); - PGWindowDef *n2 = (yyvsp[0].windef); + case 1072: +#line 3212 "third_party/libpg_query/grammar/statements/select.y" + { + PGWindowDef *n1 = (yyvsp[(2) - (4)].windef); + PGWindowDef *n2 = (yyvsp[(4) - (4)].windef); /* form merged options */ int frameOptions = n1->frameOptions; @@ -414198,732 +417788,631 @@ YYLTYPE yylloc = yyloc_default; ereport(ERROR, (errcode(PG_ERRCODE_WINDOWING_ERROR), errmsg("frame start cannot be UNBOUNDED FOLLOWING"), - parser_errposition((yylsp[-2])))); + parser_errposition((yylsp[(2) - (4)])))); if (frameOptions & FRAMEOPTION_END_UNBOUNDED_PRECEDING) ereport(ERROR, (errcode(PG_ERRCODE_WINDOWING_ERROR), errmsg("frame end cannot be UNBOUNDED PRECEDING"), - parser_errposition((yylsp[0])))); + parser_errposition((yylsp[(4) - (4)])))); if ((frameOptions & FRAMEOPTION_START_CURRENT_ROW) && (frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING)) ereport(ERROR, (errcode(PG_ERRCODE_WINDOWING_ERROR), errmsg("frame starting from current row cannot have preceding rows"), - parser_errposition((yylsp[0])))); + parser_errposition((yylsp[(4) - (4)])))); if ((frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING) && (frameOptions & (FRAMEOPTION_END_OFFSET_PRECEDING | FRAMEOPTION_END_CURRENT_ROW))) ereport(ERROR, (errcode(PG_ERRCODE_WINDOWING_ERROR), errmsg("frame starting from following row cannot have preceding rows"), - parser_errposition((yylsp[0])))); + parser_errposition((yylsp[(4) - (4)])))); n1->frameOptions = frameOptions; n1->endOffset = n2->startOffset; (yyval.windef) = n1; - } -#line 27709 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1070: /* frame_bound: UNBOUNDED PRECEDING */ -#line 3241 "third_party/libpg_query/grammar/statements/select.y" - { + case 1073: +#line 3258 "third_party/libpg_query/grammar/statements/select.y" + { PGWindowDef *n = makeNode(PGWindowDef); n->frameOptions = FRAMEOPTION_START_UNBOUNDED_PRECEDING; n->startOffset = NULL; n->endOffset = NULL; (yyval.windef) = n; - } -#line 27722 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1071: /* frame_bound: UNBOUNDED FOLLOWING */ -#line 3250 "third_party/libpg_query/grammar/statements/select.y" - { + case 1074: +#line 3267 "third_party/libpg_query/grammar/statements/select.y" + { PGWindowDef *n = makeNode(PGWindowDef); n->frameOptions = FRAMEOPTION_START_UNBOUNDED_FOLLOWING; n->startOffset = NULL; n->endOffset = NULL; (yyval.windef) = n; - } -#line 27735 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1072: /* frame_bound: CURRENT_P ROW */ -#line 3259 "third_party/libpg_query/grammar/statements/select.y" - { + case 1075: +#line 3276 "third_party/libpg_query/grammar/statements/select.y" + { PGWindowDef *n = makeNode(PGWindowDef); n->frameOptions = FRAMEOPTION_START_CURRENT_ROW; n->startOffset = NULL; n->endOffset = NULL; (yyval.windef) = n; - } -#line 27748 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1073: /* frame_bound: a_expr PRECEDING */ -#line 3268 "third_party/libpg_query/grammar/statements/select.y" - { + case 1076: +#line 3285 "third_party/libpg_query/grammar/statements/select.y" + { PGWindowDef *n = makeNode(PGWindowDef); n->frameOptions = FRAMEOPTION_START_OFFSET_PRECEDING; - n->startOffset = (yyvsp[-1].node); + n->startOffset = (yyvsp[(1) - (2)].node); n->endOffset = NULL; (yyval.windef) = n; - } -#line 27761 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1074: /* frame_bound: a_expr FOLLOWING */ -#line 3277 "third_party/libpg_query/grammar/statements/select.y" - { + case 1077: +#line 3294 "third_party/libpg_query/grammar/statements/select.y" + { PGWindowDef *n = makeNode(PGWindowDef); n->frameOptions = FRAMEOPTION_START_OFFSET_FOLLOWING; - n->startOffset = (yyvsp[-1].node); + n->startOffset = (yyvsp[(1) - (2)].node); n->endOffset = NULL; (yyval.windef) = n; - } -#line 27774 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1075: /* opt_window_exclusion_clause: EXCLUDE CURRENT_P ROW */ -#line 3288 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = FRAMEOPTION_EXCLUDE_CURRENT_ROW; } -#line 27780 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1078: +#line 3305 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = FRAMEOPTION_EXCLUDE_CURRENT_ROW; ;} break; - case 1076: /* opt_window_exclusion_clause: EXCLUDE GROUP_P */ -#line 3289 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = FRAMEOPTION_EXCLUDE_GROUP; } -#line 27786 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1079: +#line 3306 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = FRAMEOPTION_EXCLUDE_GROUP; ;} break; - case 1077: /* opt_window_exclusion_clause: EXCLUDE TIES */ -#line 3290 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = FRAMEOPTION_EXCLUDE_TIES; } -#line 27792 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1080: +#line 3307 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = FRAMEOPTION_EXCLUDE_TIES; ;} break; - case 1078: /* opt_window_exclusion_clause: EXCLUDE NO OTHERS */ -#line 3291 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 27798 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1081: +#line 3308 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = 0; ;} break; - case 1079: /* opt_window_exclusion_clause: %empty */ -#line 3292 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 27804 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1082: +#line 3309 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = 0; ;} break; - case 1080: /* qualified_row: ROW '(' expr_list_opt_comma ')' */ -#line 3306 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 27810 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1083: +#line 3323 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1081: /* qualified_row: ROW '(' ')' */ -#line 3307 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 27816 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1084: +#line 3324 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 1082: /* row: qualified_row */ -#line 3310 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list);} -#line 27822 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1085: +#line 3327 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list);;} break; - case 1083: /* row: '(' expr_list ',' a_expr ')' */ -#line 3311 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-3].list), (yyvsp[-1].node)); } -#line 27828 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1086: +#line 3328 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(2) - (5)].list), (yyvsp[(4) - (5)].node)); ;} break; - case 1084: /* dict_arg: ColIdOrString ':' a_expr */ -#line 3315 "third_party/libpg_query/grammar/statements/select.y" - { + case 1087: +#line 3332 "third_party/libpg_query/grammar/statements/select.y" + { PGNamedArgExpr *na = makeNode(PGNamedArgExpr); - na->name = (yyvsp[-2].str); - na->arg = (PGExpr *) (yyvsp[0].node); + na->name = (yyvsp[(1) - (3)].str); + na->arg = (PGExpr *) (yyvsp[(3) - (3)].node); na->argnumber = -1; - na->location = (yylsp[-2]); + na->location = (yylsp[(1) - (3)]); (yyval.node) = (PGNode *) na; - } -#line 27841 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1085: /* dict_arguments: dict_arg */ -#line 3325 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 27847 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1088: +#line 3342 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1086: /* dict_arguments: dict_arguments ',' dict_arg */ -#line 3326 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 27853 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1089: +#line 3343 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 1087: /* dict_arguments_opt_comma: dict_arguments */ -#line 3330 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 27859 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1090: +#line 3347 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1088: /* dict_arguments_opt_comma: dict_arguments ',' */ -#line 3331 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 27865 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1091: +#line 3348 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1089: /* map_arg: a_expr ':' a_expr */ -#line 3336 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make2((yyvsp[-2].node), (yyvsp[0].node)); - } -#line 27873 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1092: +#line 3353 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = list_make2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + ;} break; - case 1090: /* map_arguments: map_arg */ -#line 3342 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].list)); } -#line 27879 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1093: +#line 3359 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 1091: /* map_arguments: map_arguments ',' map_arg */ -#line 3343 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].list)); } -#line 27885 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1094: +#line 3360 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 1092: /* map_arguments_opt_comma: map_arguments */ -#line 3348 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 27891 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1095: +#line 3365 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1093: /* map_arguments_opt_comma: map_arguments ',' */ -#line 3349 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 27897 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1096: +#line 3366 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1094: /* opt_map_arguments_opt_comma: map_arguments_opt_comma */ -#line 3354 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 27903 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1097: +#line 3371 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1095: /* opt_map_arguments_opt_comma: %empty */ -#line 3355 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NULL; } -#line 27909 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1098: +#line 3372 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NULL; ;} break; - case 1096: /* sub_type: ANY */ -#line 3358 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.subquerytype) = PG_ANY_SUBLINK; } -#line 27915 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1099: +#line 3375 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.subquerytype) = PG_ANY_SUBLINK; ;} break; - case 1097: /* sub_type: SOME */ -#line 3359 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.subquerytype) = PG_ANY_SUBLINK; } -#line 27921 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1100: +#line 3376 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.subquerytype) = PG_ANY_SUBLINK; ;} break; - case 1098: /* sub_type: ALL */ -#line 3360 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.subquerytype) = PG_ALL_SUBLINK; } -#line 27927 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1101: +#line 3377 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.subquerytype) = PG_ALL_SUBLINK; ;} break; - case 1099: /* all_Op: Op */ -#line 3363 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 27933 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1102: +#line 3380 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1100: /* all_Op: MathOp */ -#line 3364 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) (yyvsp[0].conststr); } -#line 27939 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1103: +#line 3381 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) (yyvsp[(1) - (1)].conststr); ;} break; - case 1101: /* MathOp: '+' */ -#line 3367 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "+"; } -#line 27945 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1104: +#line 3384 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "+"; ;} break; - case 1102: /* MathOp: '-' */ -#line 3368 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "-"; } -#line 27951 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1105: +#line 3385 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "-"; ;} break; - case 1103: /* MathOp: '*' */ -#line 3369 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "*"; } -#line 27957 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1106: +#line 3386 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "*"; ;} break; - case 1104: /* MathOp: '/' */ -#line 3370 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "/"; } -#line 27963 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1107: +#line 3387 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "/"; ;} break; - case 1105: /* MathOp: INTEGER_DIVISION */ -#line 3371 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "//"; } -#line 27969 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1108: +#line 3388 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "//"; ;} break; - case 1106: /* MathOp: '%' */ -#line 3372 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "%"; } -#line 27975 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1109: +#line 3389 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "%"; ;} break; - case 1107: /* MathOp: '^' */ -#line 3373 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "^"; } -#line 27981 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1110: +#line 3390 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "^"; ;} break; - case 1108: /* MathOp: POWER_OF */ -#line 3374 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "**"; } -#line 27987 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1111: +#line 3391 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "**"; ;} break; - case 1109: /* MathOp: '<' */ -#line 3375 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "<"; } -#line 27993 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1112: +#line 3392 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "<"; ;} break; - case 1110: /* MathOp: '>' */ -#line 3376 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = ">"; } -#line 27999 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1113: +#line 3393 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = ">"; ;} break; - case 1111: /* MathOp: '=' */ -#line 3377 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "="; } -#line 28005 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1114: +#line 3394 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "="; ;} break; - case 1112: /* MathOp: LESS_EQUALS */ -#line 3378 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "<="; } -#line 28011 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1115: +#line 3395 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "<="; ;} break; - case 1113: /* MathOp: GREATER_EQUALS */ -#line 3379 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = ">="; } -#line 28017 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1116: +#line 3396 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = ">="; ;} break; - case 1114: /* MathOp: NOT_EQUALS */ -#line 3380 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "<>"; } -#line 28023 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1117: +#line 3397 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.conststr) = "<>"; ;} break; - case 1115: /* qual_Op: Op */ -#line 3384 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 28029 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1118: +#line 3401 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1116: /* qual_Op: OPERATOR '(' any_operator ')' */ -#line 3386 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28035 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1119: +#line 3403 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1117: /* qual_all_Op: all_Op */ -#line 3391 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 28041 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1120: +#line 3408 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1118: /* qual_all_Op: OPERATOR '(' any_operator ')' */ -#line 3393 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28047 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1121: +#line 3410 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1119: /* subquery_Op: all_Op */ -#line 3398 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 28053 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1122: +#line 3415 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1120: /* subquery_Op: OPERATOR '(' any_operator ')' */ -#line 3400 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28059 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1123: +#line 3417 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1121: /* subquery_Op: LIKE */ -#line 3402 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("~~")); } -#line 28065 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1124: +#line 3419 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString("~~")); ;} break; - case 1122: /* subquery_Op: NOT_LA LIKE */ -#line 3404 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("!~~")); } -#line 28071 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1125: +#line 3421 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString("!~~")); ;} break; - case 1123: /* subquery_Op: GLOB */ -#line 3406 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("~~~")); } -#line 28077 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1126: +#line 3423 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString("~~~")); ;} break; - case 1124: /* subquery_Op: NOT_LA GLOB */ -#line 3408 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("!~~~")); } -#line 28083 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1127: +#line 3425 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString("!~~~")); ;} break; - case 1125: /* subquery_Op: ILIKE */ -#line 3410 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("~~*")); } -#line 28089 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1128: +#line 3427 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString("~~*")); ;} break; - case 1126: /* subquery_Op: NOT_LA ILIKE */ -#line 3412 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("!~~*")); } -#line 28095 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1129: +#line 3429 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString("!~~*")); ;} break; - case 1127: /* any_operator: all_Op */ -#line 3426 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 28101 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1130: +#line 3443 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1128: /* any_operator: ColId '.' any_operator */ -#line 3428 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lcons(makeString((yyvsp[-2].str)), (yyvsp[0].list)); } -#line 28107 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1131: +#line 3445 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lcons(makeString((yyvsp[(1) - (3)].str)), (yyvsp[(3) - (3)].list)); ;} break; - case 1129: /* c_expr_list: c_expr */ -#line 3433 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 28115 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1132: +#line 3450 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 1130: /* c_expr_list: c_expr_list ',' c_expr */ -#line 3437 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 28123 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1133: +#line 3454 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 1131: /* c_expr_list_opt_comma: c_expr_list */ -#line 3444 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[0].list); - } -#line 28131 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1134: +#line 3461 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = (yyvsp[(1) - (1)].list); + ;} break; - case 1132: /* c_expr_list_opt_comma: c_expr_list ',' */ -#line 3449 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[-1].list); - } -#line 28139 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1135: +#line 3466 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = (yyvsp[(1) - (2)].list); + ;} break; - case 1133: /* expr_list: a_expr */ -#line 3455 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 28147 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1136: +#line 3472 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 1134: /* expr_list: expr_list ',' a_expr */ -#line 3459 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 28155 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1137: +#line 3476 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 1135: /* expr_list_opt_comma: expr_list */ -#line 3466 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[0].list); - } -#line 28163 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1138: +#line 3483 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = (yyvsp[(1) - (1)].list); + ;} break; - case 1136: /* expr_list_opt_comma: expr_list ',' */ -#line 3471 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[-1].list); - } -#line 28171 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1139: +#line 3488 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = (yyvsp[(1) - (2)].list); + ;} break; - case 1137: /* opt_expr_list_opt_comma: expr_list_opt_comma */ -#line 3478 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[0].list); - } -#line 28179 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1140: +#line 3495 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = (yyvsp[(1) - (1)].list); + ;} break; - case 1138: /* opt_expr_list_opt_comma: %empty */ -#line 3482 "third_party/libpg_query/grammar/statements/select.y" - { + case 1141: +#line 3499 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NULL; - } -#line 28187 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1139: /* func_arg_list: func_arg_expr */ -#line 3491 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 28195 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1142: +#line 3508 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 1140: /* func_arg_list: func_arg_list ',' func_arg_expr */ -#line 3495 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 28203 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1143: +#line 3512 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 1141: /* func_arg_expr: a_expr */ -#line 3501 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 28211 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1144: +#line 3518 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 1142: /* func_arg_expr: param_name COLON_EQUALS a_expr */ -#line 3505 "third_party/libpg_query/grammar/statements/select.y" - { + case 1145: +#line 3522 "third_party/libpg_query/grammar/statements/select.y" + { PGNamedArgExpr *na = makeNode(PGNamedArgExpr); - na->name = (yyvsp[-2].str); - na->arg = (PGExpr *) (yyvsp[0].node); + na->name = (yyvsp[(1) - (3)].str); + na->arg = (PGExpr *) (yyvsp[(3) - (3)].node); na->argnumber = -1; /* until determined */ - na->location = (yylsp[-2]); + na->location = (yylsp[(1) - (3)]); (yyval.node) = (PGNode *) na; - } -#line 28224 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1143: /* func_arg_expr: param_name EQUALS_GREATER a_expr */ -#line 3514 "third_party/libpg_query/grammar/statements/select.y" - { + case 1146: +#line 3531 "third_party/libpg_query/grammar/statements/select.y" + { PGNamedArgExpr *na = makeNode(PGNamedArgExpr); - na->name = (yyvsp[-2].str); - na->arg = (PGExpr *) (yyvsp[0].node); + na->name = (yyvsp[(1) - (3)].str); + na->arg = (PGExpr *) (yyvsp[(3) - (3)].node); na->argnumber = -1; /* until determined */ - na->location = (yylsp[-2]); + na->location = (yylsp[(1) - (3)]); (yyval.node) = (PGNode *) na; - } -#line 28237 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1144: /* type_list: Typename */ -#line 3524 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].typnam)); } -#line 28243 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1147: +#line 3541 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].typnam)); ;} break; - case 1145: /* type_list: type_list ',' Typename */ -#line 3525 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].typnam)); } -#line 28249 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1148: +#line 3542 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].typnam)); ;} break; - case 1146: /* extract_list: extract_arg FROM a_expr */ -#line 3530 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make2(makeStringConst((yyvsp[-2].str), (yylsp[-2])), (yyvsp[0].node)); - } -#line 28257 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1149: +#line 3547 "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 1147: /* extract_list: %empty */ -#line 3533 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 28263 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1150: +#line 3550 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 1148: /* extract_arg: IDENT */ -#line 3540 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 28269 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1151: +#line 3557 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1149: /* extract_arg: year_keyword */ -#line 3541 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "year"; } -#line 28275 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1152: +#line 3558 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "year"; ;} break; - case 1150: /* extract_arg: month_keyword */ -#line 3542 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "month"; } -#line 28281 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1153: +#line 3559 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "month"; ;} break; - case 1151: /* extract_arg: day_keyword */ -#line 3543 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "day"; } -#line 28287 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1154: +#line 3560 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "day"; ;} break; - case 1152: /* extract_arg: hour_keyword */ -#line 3544 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "hour"; } -#line 28293 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1155: +#line 3561 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "hour"; ;} break; - case 1153: /* extract_arg: minute_keyword */ -#line 3545 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "minute"; } -#line 28299 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1156: +#line 3562 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "minute"; ;} break; - case 1154: /* extract_arg: second_keyword */ -#line 3546 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "second"; } -#line 28305 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1157: +#line 3563 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "second"; ;} break; - case 1155: /* extract_arg: millisecond_keyword */ -#line 3547 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "millisecond"; } -#line 28311 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1158: +#line 3564 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "millisecond"; ;} break; - case 1156: /* extract_arg: microsecond_keyword */ -#line 3548 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "microsecond"; } -#line 28317 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1159: +#line 3565 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "microsecond"; ;} break; - case 1157: /* extract_arg: week_keyword */ -#line 3549 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "week"; } -#line 28323 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1160: +#line 3566 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "week"; ;} break; - case 1158: /* extract_arg: decade_keyword */ -#line 3550 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "decade"; } -#line 28329 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1161: +#line 3567 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "decade"; ;} break; - case 1159: /* extract_arg: century_keyword */ -#line 3551 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "century"; } -#line 28335 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1162: +#line 3568 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "century"; ;} break; - case 1160: /* extract_arg: millennium_keyword */ -#line 3552 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "millennium"; } -#line 28341 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1163: +#line 3569 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (char*) "millennium"; ;} break; - case 1161: /* extract_arg: Sconst */ -#line 3553 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 28347 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1164: +#line 3570 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1162: /* overlay_list: a_expr overlay_placing substr_from substr_for */ -#line 3564 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make4((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[-1].node), (yyvsp[0].node)); - } -#line 28355 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1165: +#line 3581 "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 1163: /* overlay_list: a_expr overlay_placing substr_from */ -#line 3568 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make3((yyvsp[-2].node), (yyvsp[-1].node), (yyvsp[0].node)); - } -#line 28363 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1166: +#line 3585 "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 1164: /* overlay_placing: PLACING a_expr */ -#line 3575 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28369 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1167: +#line 3592 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1165: /* position_list: b_expr IN_P b_expr */ -#line 3581 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[0].node), (yyvsp[-2].node)); } -#line 28375 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1168: +#line 3598 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make2((yyvsp[(3) - (3)].node), (yyvsp[(1) - (3)].node)); ;} break; - case 1166: /* position_list: %empty */ -#line 3582 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 28381 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1169: +#line 3599 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 1167: /* substr_list: a_expr substr_from substr_for */ -#line 3599 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make3((yyvsp[-2].node), (yyvsp[-1].node), (yyvsp[0].node)); - } -#line 28389 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1170: +#line 3616 "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 1168: /* substr_list: a_expr substr_for substr_from */ -#line 3603 "third_party/libpg_query/grammar/statements/select.y" - { + case 1171: +#line 3620 "third_party/libpg_query/grammar/statements/select.y" + { /* not legal per SQL99, but might as well allow it */ - (yyval.list) = list_make3((yyvsp[-2].node), (yyvsp[0].node), (yyvsp[-1].node)); - } -#line 28398 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yyvsp[(2) - (3)].node)); + ;} break; - case 1169: /* substr_list: a_expr substr_from */ -#line 3608 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make2((yyvsp[-1].node), (yyvsp[0].node)); - } -#line 28406 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1172: +#line 3625 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); + ;} break; - case 1170: /* substr_list: a_expr substr_for */ -#line 3612 "third_party/libpg_query/grammar/statements/select.y" - { + case 1173: +#line 3629 "third_party/libpg_query/grammar/statements/select.y" + { /* * Since there are no cases where this syntax allows * a textual FOR value, we forcibly cast the argument @@ -414933,599 +418422,523 @@ YYLTYPE yylloc = yyloc_default; * which it is likely to do if the second argument * is unknown or doesn't have an implicit cast to int4. */ - (yyval.list) = list_make3((yyvsp[-1].node), makeIntConst(1, -1), - makeTypeCast((yyvsp[0].node), + (yyval.list) = list_make3((yyvsp[(1) - (2)].node), makeIntConst(1, -1), + makeTypeCast((yyvsp[(2) - (2)].node), SystemTypeName("int4"), 0, -1)); - } -#line 28425 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1171: /* substr_list: expr_list */ -#line 3627 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[0].list); - } -#line 28433 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1174: +#line 3644 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = (yyvsp[(1) - (1)].list); + ;} break; - case 1172: /* substr_list: %empty */ -#line 3631 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 28439 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1175: +#line 3648 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 1173: /* substr_from: FROM a_expr */ -#line 3635 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28445 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1176: +#line 3652 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1174: /* substr_for: FOR a_expr */ -#line 3638 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28451 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1177: +#line 3655 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1175: /* trim_list: a_expr FROM expr_list_opt_comma */ -#line 3641 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[0].list), (yyvsp[-2].node)); } -#line 28457 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1178: +#line 3658 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(3) - (3)].list), (yyvsp[(1) - (3)].node)); ;} break; - case 1176: /* trim_list: FROM expr_list_opt_comma */ -#line 3642 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28463 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1179: +#line 3659 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1177: /* trim_list: expr_list_opt_comma */ -#line 3643 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28469 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1180: +#line 3660 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1178: /* in_expr: select_with_parens */ -#line 3647 "third_party/libpg_query/grammar/statements/select.y" - { + case 1181: +#line 3664 "third_party/libpg_query/grammar/statements/select.y" + { PGSubLink *n = makeNode(PGSubLink); - n->subselect = (yyvsp[0].node); + n->subselect = (yyvsp[(1) - (1)].node); /* other fields will be filled later */ (yyval.node) = (PGNode *)n; - } -#line 28480 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1179: /* in_expr: '(' expr_list_opt_comma ')' */ -#line 3653 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *)(yyvsp[-1].list); } -#line 28486 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1182: +#line 3670 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (PGNode *)(yyvsp[(2) - (3)].list); ;} break; - case 1180: /* case_expr: CASE case_arg when_clause_list case_default END_P */ -#line 3664 "third_party/libpg_query/grammar/statements/select.y" - { + case 1183: +#line 3681 "third_party/libpg_query/grammar/statements/select.y" + { PGCaseExpr *c = makeNode(PGCaseExpr); c->casetype = InvalidOid; /* not analyzed yet */ - c->arg = (PGExpr *) (yyvsp[-3].node); - c->args = (yyvsp[-2].list); - c->defresult = (PGExpr *) (yyvsp[-1].node); - c->location = (yylsp[-4]); + c->arg = (PGExpr *) (yyvsp[(2) - (5)].node); + c->args = (yyvsp[(3) - (5)].list); + c->defresult = (PGExpr *) (yyvsp[(4) - (5)].node); + c->location = (yylsp[(1) - (5)]); (yyval.node) = (PGNode *)c; - } -#line 28500 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1181: /* when_clause_list: when_clause */ -#line 3677 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 28506 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1184: +#line 3694 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1182: /* when_clause_list: when_clause_list when_clause */ -#line 3678 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 28512 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1185: +#line 3695 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 1183: /* when_clause: WHEN a_expr THEN a_expr */ -#line 3683 "third_party/libpg_query/grammar/statements/select.y" - { + case 1186: +#line 3700 "third_party/libpg_query/grammar/statements/select.y" + { PGCaseWhen *w = makeNode(PGCaseWhen); - w->expr = (PGExpr *) (yyvsp[-2].node); - w->result = (PGExpr *) (yyvsp[0].node); - w->location = (yylsp[-3]); + w->expr = (PGExpr *) (yyvsp[(2) - (4)].node); + w->result = (PGExpr *) (yyvsp[(4) - (4)].node); + w->location = (yylsp[(1) - (4)]); (yyval.node) = (PGNode *)w; - } -#line 28524 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1184: /* case_default: ELSE a_expr */ -#line 3693 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28530 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1187: +#line 3710 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1185: /* case_default: %empty */ -#line 3694 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 28536 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1188: +#line 3711 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 1186: /* case_arg: a_expr */ -#line 3697 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28542 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1189: +#line 3714 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1187: /* case_arg: %empty */ -#line 3698 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 28548 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1190: +#line 3715 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 1188: /* columnref: ColId */ -#line 3702 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeColumnRef((yyvsp[0].str), NIL, (yylsp[0]), yyscanner); - } -#line 28556 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1191: +#line 3719 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeColumnRef((yyvsp[(1) - (1)].str), NIL, (yylsp[(1) - (1)]), yyscanner); + ;} break; - case 1189: /* columnref: ColId indirection */ -#line 3706 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeColumnRef((yyvsp[-1].str), (yyvsp[0].list), (yylsp[-1]), yyscanner); - } -#line 28564 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1192: +#line 3723 "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 1190: /* indirection_el: '[' a_expr ']' */ -#line 3713 "third_party/libpg_query/grammar/statements/select.y" - { + case 1193: +#line 3730 "third_party/libpg_query/grammar/statements/select.y" + { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = false; ai->lidx = NULL; - ai->uidx = (yyvsp[-1].node); + ai->uidx = (yyvsp[(2) - (3)].node); (yyval.node) = (PGNode *) ai; - } -#line 28576 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1191: /* indirection_el: '[' opt_slice_bound ':' opt_slice_bound ']' */ -#line 3721 "third_party/libpg_query/grammar/statements/select.y" - { + case 1194: +#line 3738 "third_party/libpg_query/grammar/statements/select.y" + { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; - ai->lidx = (yyvsp[-3].node); - ai->uidx = (yyvsp[-1].node); + ai->lidx = (yyvsp[(2) - (5)].node); + ai->uidx = (yyvsp[(4) - (5)].node); (yyval.node) = (PGNode *) ai; - } -#line 28588 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1192: /* indirection_el: '[' opt_slice_bound ':' opt_slice_bound ':' opt_slice_bound ']' */ -#line 3728 "third_party/libpg_query/grammar/statements/select.y" - { + case 1195: +#line 3745 "third_party/libpg_query/grammar/statements/select.y" + { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; - ai->lidx = (yyvsp[-5].node); - ai->uidx = (yyvsp[-3].node); - ai->step = (yyvsp[-1].node); + ai->lidx = (yyvsp[(2) - (7)].node); + ai->uidx = (yyvsp[(4) - (7)].node); + ai->step = (yyvsp[(6) - (7)].node); (yyval.node) = (PGNode *) ai; - } -#line 28601 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1193: /* indirection_el: '[' opt_slice_bound ':' '-' ':' opt_slice_bound ']' */ -#line 3736 "third_party/libpg_query/grammar/statements/select.y" - { + case 1196: +#line 3753 "third_party/libpg_query/grammar/statements/select.y" + { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; - ai->lidx = (yyvsp[-5].node); - ai->step = (yyvsp[-1].node); + ai->lidx = (yyvsp[(2) - (7)].node); + ai->step = (yyvsp[(6) - (7)].node); (yyval.node) = (PGNode *) ai; - } -#line 28613 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1194: /* opt_slice_bound: a_expr */ -#line 3746 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28619 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1197: +#line 3763 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1195: /* opt_slice_bound: %empty */ -#line 3747 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 28625 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1198: +#line 3764 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.node) = NULL; ;} break; - case 1196: /* opt_indirection: %empty */ -#line 3752 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 28631 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1199: +#line 3769 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 1197: /* opt_indirection: opt_indirection indirection_el */ -#line 3753 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 28637 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1200: +#line 3770 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 1198: /* opt_func_arguments: %empty */ -#line 3757 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NULL; } -#line 28643 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1201: +#line 3774 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NULL; ;} break; - case 1199: /* opt_func_arguments: '(' ')' */ -#line 3758 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(NULL); } -#line 28649 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1202: +#line 3775 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(NULL); ;} break; - case 1200: /* opt_func_arguments: '(' func_arg_list ')' */ -#line 3759 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28655 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1203: +#line 3776 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1201: /* extended_indirection_el: '.' attr_name opt_func_arguments */ -#line 3764 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].list)) { - PGFuncCall *n = makeFuncCall(list_make1(makeString((yyvsp[-1].str))), (yyvsp[0].list)->head->data.ptr_value ? (yyvsp[0].list) : NULL, (yylsp[-1])); + case 1204: +#line 3781 "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)])); (yyval.node) = (PGNode *) n; } else { - (yyval.node) = (PGNode *) makeString((yyvsp[-1].str)); + (yyval.node) = (PGNode *) makeString((yyvsp[(2) - (3)].str)); } - } -#line 28668 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1202: /* extended_indirection_el: '[' a_expr ']' */ -#line 3773 "third_party/libpg_query/grammar/statements/select.y" - { + case 1205: +#line 3790 "third_party/libpg_query/grammar/statements/select.y" + { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = false; ai->lidx = NULL; - ai->uidx = (yyvsp[-1].node); + ai->uidx = (yyvsp[(2) - (3)].node); (yyval.node) = (PGNode *) ai; - } -#line 28680 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1203: /* extended_indirection_el: '[' opt_slice_bound ':' opt_slice_bound ']' */ -#line 3781 "third_party/libpg_query/grammar/statements/select.y" - { + case 1206: +#line 3798 "third_party/libpg_query/grammar/statements/select.y" + { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; - ai->lidx = (yyvsp[-3].node); - ai->uidx = (yyvsp[-1].node); + ai->lidx = (yyvsp[(2) - (5)].node); + ai->uidx = (yyvsp[(4) - (5)].node); (yyval.node) = (PGNode *) ai; - } -#line 28692 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1204: /* extended_indirection_el: '[' opt_slice_bound ':' opt_slice_bound ':' opt_slice_bound ']' */ -#line 3788 "third_party/libpg_query/grammar/statements/select.y" - { + case 1207: +#line 3805 "third_party/libpg_query/grammar/statements/select.y" + { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; - ai->lidx = (yyvsp[-5].node); - ai->uidx = (yyvsp[-3].node); - ai->step = (yyvsp[-1].node); + ai->lidx = (yyvsp[(2) - (7)].node); + ai->uidx = (yyvsp[(4) - (7)].node); + ai->step = (yyvsp[(6) - (7)].node); (yyval.node) = (PGNode *) ai; - } -#line 28705 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1205: /* extended_indirection_el: '[' opt_slice_bound ':' '-' ':' opt_slice_bound ']' */ -#line 3797 "third_party/libpg_query/grammar/statements/select.y" - { + case 1208: +#line 3814 "third_party/libpg_query/grammar/statements/select.y" + { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; - ai->lidx = (yyvsp[-5].node); - ai->step = (yyvsp[-1].node); + ai->lidx = (yyvsp[(2) - (7)].node); + ai->step = (yyvsp[(6) - (7)].node); (yyval.node) = (PGNode *) ai; - } -#line 28717 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1206: /* opt_extended_indirection: %empty */ -#line 3812 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 28723 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1209: +#line 3829 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 1207: /* opt_extended_indirection: opt_extended_indirection extended_indirection_el */ -#line 3813 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 28729 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1210: +#line 3830 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 1210: /* opt_target_list_opt_comma: target_list_opt_comma */ -#line 3829 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28735 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1213: +#line 3846 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1211: /* opt_target_list_opt_comma: %empty */ -#line 3830 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 28741 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1214: +#line 3847 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 1212: /* target_list: target_el */ -#line 3834 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].target)); } -#line 28747 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1215: +#line 3851 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} break; - case 1213: /* target_list: target_list ',' target_el */ -#line 3835 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].target)); } -#line 28753 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1216: +#line 3852 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;} break; - case 1214: /* target_list_opt_comma: target_list */ -#line 3839 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28759 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1217: +#line 3856 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1215: /* target_list_opt_comma: target_list ',' */ -#line 3840 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28765 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1218: +#line 3857 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1216: /* target_el: a_expr AS ColLabelOrString */ -#line 3844 "third_party/libpg_query/grammar/statements/select.y" - { + case 1219: +#line 3861 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.target) = makeNode(PGResTarget); - (yyval.target)->name = (yyvsp[0].str); + (yyval.target)->name = (yyvsp[(3) - (3)].str); (yyval.target)->indirection = NIL; - (yyval.target)->val = (PGNode *)(yyvsp[-2].node); - (yyval.target)->location = (yylsp[-2]); - } -#line 28777 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.target)->val = (PGNode *)(yyvsp[(1) - (3)].node); + (yyval.target)->location = (yylsp[(1) - (3)]); + ;} break; - case 1217: /* target_el: a_expr IDENT */ -#line 3860 "third_party/libpg_query/grammar/statements/select.y" - { + case 1220: +#line 3877 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.target) = makeNode(PGResTarget); - (yyval.target)->name = (yyvsp[0].str); + (yyval.target)->name = (yyvsp[(2) - (2)].str); (yyval.target)->indirection = NIL; - (yyval.target)->val = (PGNode *)(yyvsp[-1].node); - (yyval.target)->location = (yylsp[-1]); - } -#line 28789 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.target)->val = (PGNode *)(yyvsp[(1) - (2)].node); + (yyval.target)->location = (yylsp[(1) - (2)]); + ;} break; - case 1218: /* target_el: a_expr */ -#line 3868 "third_party/libpg_query/grammar/statements/select.y" - { + case 1221: +#line 3885 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.target) = makeNode(PGResTarget); (yyval.target)->name = NULL; (yyval.target)->indirection = NIL; - (yyval.target)->val = (PGNode *)(yyvsp[0].node); - (yyval.target)->location = (yylsp[0]); - } -#line 28801 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.target)->val = (PGNode *)(yyvsp[(1) - (1)].node); + (yyval.target)->location = (yylsp[(1) - (1)]); + ;} break; - case 1219: /* except_list: EXCLUDE '(' name_list_opt_comma ')' */ -#line 3877 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28807 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1222: +#line 3894 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1220: /* except_list: EXCLUDE ColId */ -#line 3878 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 28813 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1223: +#line 3895 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString((yyvsp[(2) - (2)].str))); ;} break; - case 1221: /* opt_except_list: except_list */ -#line 3881 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28819 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1224: +#line 3898 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1222: /* opt_except_list: %empty */ -#line 3882 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NULL; } -#line 28825 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1225: +#line 3899 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NULL; ;} break; - case 1223: /* replace_list_el: a_expr AS ColId */ -#line 3885 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[-2].node), makeString((yyvsp[0].str))); } -#line 28831 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1226: +#line 3902 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 1224: /* replace_list: replace_list_el */ -#line 3889 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].list)); } -#line 28837 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1227: +#line 3906 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 1225: /* replace_list: replace_list ',' replace_list_el */ -#line 3890 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].list)); } -#line 28843 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1228: +#line 3907 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 1226: /* replace_list_opt_comma: replace_list */ -#line 3894 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28849 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1229: +#line 3911 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1227: /* replace_list_opt_comma: replace_list ',' */ -#line 3895 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28855 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1230: +#line 3912 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1228: /* opt_replace_list: REPLACE '(' replace_list_opt_comma ')' */ -#line 3898 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28861 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1231: +#line 3915 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1229: /* opt_replace_list: REPLACE replace_list_el */ -#line 3899 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].list)); } -#line 28867 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1232: +#line 3916 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;} break; - case 1230: /* opt_replace_list: %empty */ -#line 3900 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NULL; } -#line 28873 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1233: +#line 3917 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NULL; ;} break; - case 1231: /* qualified_name_list: qualified_name */ -#line 3910 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].range)); } -#line 28879 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1234: +#line 3927 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].range)); ;} break; - case 1232: /* qualified_name_list: qualified_name_list ',' qualified_name */ -#line 3911 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].range)); } -#line 28885 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1235: +#line 3928 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].range)); ;} break; - case 1233: /* name_list: name */ -#line 3916 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 28891 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1236: +#line 3933 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1234: /* name_list: name_list ',' name */ -#line 3918 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), makeString((yyvsp[0].str))); } -#line 28897 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1237: +#line 3935 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 1235: /* name_list_opt_comma: name_list */ -#line 3923 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28903 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1238: +#line 3940 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1236: /* name_list_opt_comma: name_list ',' */ -#line 3924 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28909 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1239: +#line 3941 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1237: /* name_list_opt_comma_opt_bracket: name_list_opt_comma */ -#line 3928 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28915 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1240: +#line 3945 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1238: /* name_list_opt_comma_opt_bracket: '(' name_list_opt_comma ')' */ -#line 3929 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28921 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1241: +#line 3946 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1239: /* name: ColIdOrString */ -#line 3932 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 28927 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1242: +#line 3949 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1240: /* func_name: function_name_token */ -#line 3944 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 28933 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1243: +#line 3961 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1241: /* func_name: ColId indirection */ -#line 3947 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = check_func_name(lcons(makeString((yyvsp[-1].str)), (yyvsp[0].list)), + case 1244: +#line 3964 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.list) = check_func_name(lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)), yyscanner); - } -#line 28942 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1242: /* AexprConst: Iconst */ -#line 3958 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeIntConst((yyvsp[0].ival), (yylsp[0])); - } -#line 28950 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1245: +#line 3975 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival), (yylsp[(1) - (1)])); + ;} break; - case 1243: /* AexprConst: FCONST */ -#line 3962 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeFloatConst((yyvsp[0].str), (yylsp[0])); - } -#line 28958 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1246: +#line 3979 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 1244: /* AexprConst: Sconst opt_indirection */ -#line 3966 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].list)) + case 1247: +#line 3983 "third_party/libpg_query/grammar/statements/select.y" + { + if ((yyvsp[(2) - (2)].list)) { PGAIndirection *n = makeNode(PGAIndirection); - n->arg = makeStringConst((yyvsp[-1].str), (yylsp[-1])); - n->indirection = check_indirection((yyvsp[0].list), yyscanner); + n->arg = makeStringConst((yyvsp[(1) - (2)].str), (yylsp[(1) - (2)])); + n->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner); (yyval.node) = (PGNode *) n; } else - (yyval.node) = makeStringConst((yyvsp[-1].str), (yylsp[-1])); - } -#line 28974 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = makeStringConst((yyvsp[(1) - (2)].str), (yylsp[(1) - (2)])); + ;} break; - case 1245: /* AexprConst: BCONST */ -#line 3978 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeBitStringConst((yyvsp[0].str), (yylsp[0])); - } -#line 28982 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1248: +#line 3995 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeBitStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 1246: /* AexprConst: XCONST */ -#line 3982 "third_party/libpg_query/grammar/statements/select.y" - { + case 1249: +#line 3999 "third_party/libpg_query/grammar/statements/select.y" + { /* This is a bit constant per SQL99: * Without Feature F511, "BIT data type", * a shall not be a * or a . */ - (yyval.node) = makeBitStringConst((yyvsp[0].str), (yylsp[0])); - } -#line 28995 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = makeBitStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 1247: /* AexprConst: func_name Sconst */ -#line 3991 "third_party/libpg_query/grammar/statements/select.y" - { + case 1250: +#line 4008 "third_party/libpg_query/grammar/statements/select.y" + { /* generic type 'literal' syntax */ - PGTypeName *t = makeTypeNameFromNameList((yyvsp[-1].list)); - t->location = (yylsp[-1]); - (yyval.node) = makeStringConstCast((yyvsp[0].str), (yylsp[0]), t); - } -#line 29006 "third_party/libpg_query/grammar/grammar_out.cpp" + PGTypeName *t = makeTypeNameFromNameList((yyvsp[(1) - (2)].list)); + t->location = (yylsp[(1) - (2)]); + (yyval.node) = makeStringConstCast((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)]), t); + ;} break; - case 1248: /* AexprConst: func_name '(' func_arg_list opt_sort_clause opt_ignore_nulls ')' Sconst */ -#line 3998 "third_party/libpg_query/grammar/statements/select.y" - { + case 1251: +#line 4015 "third_party/libpg_query/grammar/statements/select.y" + { /* generic syntax with a type modifier */ - PGTypeName *t = makeTypeNameFromNameList((yyvsp[-6].list)); + PGTypeName *t = makeTypeNameFromNameList((yyvsp[(1) - (7)].list)); PGListCell *lc; /* @@ -415534,7 +418947,7 @@ YYLTYPE yylloc = yyloc_default; * don't actually wish to allow PGNamedArgExpr in this * context, ORDER BY, nor IGNORE NULLS. */ - foreach(lc, (yyvsp[-4].list)) + foreach(lc, (yyvsp[(3) - (7)].list)) { PGNamedArgExpr *arg = (PGNamedArgExpr *) lfirst(lc); @@ -415544,315 +418957,281 @@ YYLTYPE yylloc = yyloc_default; errmsg("type modifier cannot have parameter name"), parser_errposition(arg->location))); } - if ((yyvsp[-3].list) != NIL) + if ((yyvsp[(4) - (7)].list) != NIL) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("type modifier cannot have ORDER BY"), - parser_errposition((yylsp[-3])))); - if ((yyvsp[-2].boolean) != false) + parser_errposition((yylsp[(4) - (7)])))); + if ((yyvsp[(5) - (7)].boolean) != false) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("type modifier cannot have IGNORE NULLS"), - parser_errposition((yylsp[-2])))); + parser_errposition((yylsp[(5) - (7)])))); - t->typmods = (yyvsp[-4].list); - t->location = (yylsp[-6]); - (yyval.node) = makeStringConstCast((yyvsp[0].str), (yylsp[0]), t); - } -#line 29048 "third_party/libpg_query/grammar/grammar_out.cpp" + t->typmods = (yyvsp[(3) - (7)].list); + t->location = (yylsp[(1) - (7)]); + (yyval.node) = makeStringConstCast((yyvsp[(7) - (7)].str), (yylsp[(7) - (7)]), t); + ;} break; - case 1249: /* AexprConst: ConstTypename Sconst */ -#line 4036 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeStringConstCast((yyvsp[0].str), (yylsp[0]), (yyvsp[-1].typnam)); - } -#line 29056 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1252: +#line 4053 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeStringConstCast((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)]), (yyvsp[(1) - (2)].typnam)); + ;} break; - case 1250: /* AexprConst: ConstInterval '(' a_expr ')' opt_interval */ -#line 4040 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeIntervalNode((yyvsp[-2].node), (yylsp[-2]), (yyvsp[0].list)); - } -#line 29064 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1253: +#line 4057 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeIntervalNode((yyvsp[(3) - (5)].node), (yylsp[(3) - (5)]), (yyvsp[(5) - (5)].list)); + ;} break; - case 1251: /* AexprConst: ConstInterval Iconst opt_interval */ -#line 4044 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeIntervalNode((yyvsp[-1].ival), (yylsp[-1]), (yyvsp[0].list)); - } -#line 29072 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1254: +#line 4061 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].ival), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list)); + ;} break; - case 1252: /* AexprConst: ConstInterval Sconst opt_interval */ -#line 4048 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeIntervalNode((yyvsp[-1].str), (yylsp[-1]), (yyvsp[0].list)); - } -#line 29080 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1255: +#line 4065 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].str), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list)); + ;} break; - case 1253: /* AexprConst: TRUE_P */ -#line 4052 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeBoolAConst(true, (yylsp[0])); - } -#line 29088 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1256: +#line 4069 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeBoolAConst(true, (yylsp[(1) - (1)])); + ;} break; - case 1254: /* AexprConst: FALSE_P */ -#line 4056 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeBoolAConst(false, (yylsp[0])); - } -#line 29096 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1257: +#line 4073 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeBoolAConst(false, (yylsp[(1) - (1)])); + ;} break; - case 1255: /* AexprConst: NULL_P */ -#line 4060 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeNullAConst((yylsp[0])); - } -#line 29104 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1258: +#line 4077 "third_party/libpg_query/grammar/statements/select.y" + { + (yyval.node) = makeNullAConst((yylsp[(1) - (1)])); + ;} break; - case 1256: /* Iconst: ICONST */ -#line 4065 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = (yyvsp[0].ival); } -#line 29110 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1259: +#line 4082 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} break; - case 1257: /* type_function_name: IDENT */ -#line 4082 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29116 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1260: +#line 4099 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1258: /* type_function_name: unreserved_keyword */ -#line 4083 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29122 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1261: +#line 4100 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1259: /* type_function_name: type_func_name_keyword */ -#line 4084 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29128 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1262: +#line 4101 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1260: /* function_name_token: IDENT */ -#line 4087 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29134 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1263: +#line 4104 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1261: /* function_name_token: unreserved_keyword */ -#line 4088 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29140 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1264: +#line 4105 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1262: /* function_name_token: func_name_keyword */ -#line 4089 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29146 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1265: +#line 4106 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1263: /* type_name_token: IDENT */ -#line 4092 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29152 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1266: +#line 4109 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1264: /* type_name_token: unreserved_keyword */ -#line 4093 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29158 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1267: +#line 4110 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1265: /* type_name_token: type_name_keyword */ -#line 4094 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29164 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1268: +#line 4111 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1266: /* any_name: ColId */ -#line 4097 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 29170 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1269: +#line 4114 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1267: /* any_name: ColId attrs */ -#line 4098 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lcons(makeString((yyvsp[-1].str)), (yyvsp[0].list)); } -#line 29176 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1270: +#line 4115 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)); ;} break; - case 1268: /* attrs: '.' attr_name */ -#line 4102 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 29182 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1271: +#line 4119 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = list_make1(makeString((yyvsp[(2) - (2)].str))); ;} break; - case 1269: /* attrs: attrs '.' attr_name */ -#line 4104 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), makeString((yyvsp[0].str))); } -#line 29188 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1272: +#line 4121 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 1270: /* opt_name_list: '(' name_list_opt_comma ')' */ -#line 4108 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 29194 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1273: +#line 4125 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1271: /* opt_name_list: %empty */ -#line 4109 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 29200 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1274: +#line 4126 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.list) = NIL; ;} break; - case 1273: /* ColLabelOrString: ColLabel */ -#line 4116 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29206 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1276: +#line 4133 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1274: /* ColLabelOrString: SCONST */ -#line 4117 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29212 "third_party/libpg_query/grammar/grammar_out.cpp" + case 1277: +#line 4134 "third_party/libpg_query/grammar/statements/select.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1275: /* PrepareStmt: PREPARE name prep_type_clause AS PreparableStmt */ + case 1278: #line 8 "third_party/libpg_query/grammar/statements/prepare.y" - { + { PGPrepareStmt *n = makeNode(PGPrepareStmt); - n->name = (yyvsp[-3].str); - n->argtypes = (yyvsp[-2].list); - n->query = (yyvsp[0].node); + n->name = (yyvsp[(2) - (5)].str); + n->argtypes = (yyvsp[(3) - (5)].list); + n->query = (yyvsp[(5) - (5)].node); (yyval.node) = (PGNode *) n; - } -#line 29224 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1276: /* prep_type_clause: '(' type_list ')' */ + case 1279: #line 18 "third_party/libpg_query/grammar/statements/prepare.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 29230 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1277: /* prep_type_clause: %empty */ + case 1280: #line 19 "third_party/libpg_query/grammar/statements/prepare.y" - { (yyval.list) = NIL; } -#line 29236 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1284: /* CreateSchemaStmt: CREATE_P SCHEMA qualified_name OptSchemaEltList */ + case 1287: #line 8 "third_party/libpg_query/grammar/statements/create_schema.y" - { + { PGCreateSchemaStmt *n = makeNode(PGCreateSchemaStmt); - if ((yyvsp[-1].range)->catalogname) { + if ((yyvsp[(3) - (4)].range)->catalogname) { ereport(ERROR, (errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("CREATE SCHEMA too many dots: expected \"catalog.schema\" or \"schema\""), - parser_errposition((yylsp[-1])))); + parser_errposition((yylsp[(3) - (4)])))); } - if ((yyvsp[-1].range)->schemaname) { - n->catalogname = (yyvsp[-1].range)->schemaname; - n->schemaname = (yyvsp[-1].range)->relname; + if ((yyvsp[(3) - (4)].range)->schemaname) { + n->catalogname = (yyvsp[(3) - (4)].range)->schemaname; + n->schemaname = (yyvsp[(3) - (4)].range)->relname; } else { - n->schemaname = (yyvsp[-1].range)->relname; + n->schemaname = (yyvsp[(3) - (4)].range)->relname; } - n->schemaElts = (yyvsp[0].list); + n->schemaElts = (yyvsp[(4) - (4)].list); n->onconflict = PG_ERROR_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 29259 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1285: /* CreateSchemaStmt: CREATE_P SCHEMA IF_P NOT EXISTS qualified_name OptSchemaEltList */ + case 1288: #line 27 "third_party/libpg_query/grammar/statements/create_schema.y" - { + { PGCreateSchemaStmt *n = makeNode(PGCreateSchemaStmt); - if ((yyvsp[-1].range)->catalogname) { + if ((yyvsp[(6) - (7)].range)->catalogname) { ereport(ERROR, (errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("CREATE SCHEMA too many dots: expected \"catalog.schema\" or \"schema\""), - parser_errposition((yylsp[-1])))); + parser_errposition((yylsp[(6) - (7)])))); } - if ((yyvsp[-1].range)->schemaname) { - n->catalogname = (yyvsp[-1].range)->schemaname; - n->schemaname = (yyvsp[-1].range)->relname; + if ((yyvsp[(6) - (7)].range)->schemaname) { + n->catalogname = (yyvsp[(6) - (7)].range)->schemaname; + n->schemaname = (yyvsp[(6) - (7)].range)->relname; } else { - n->schemaname = (yyvsp[-1].range)->relname; + n->schemaname = (yyvsp[(6) - (7)].range)->relname; } - if ((yyvsp[0].list) != NIL) + if ((yyvsp[(7) - (7)].list) != NIL) ereport(ERROR, (errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("CREATE SCHEMA IF NOT EXISTS cannot include schema elements"), - parser_errposition((yylsp[0])))); - n->schemaElts = (yyvsp[0].list); + parser_errposition((yylsp[(7) - (7)])))); + n->schemaElts = (yyvsp[(7) - (7)].list); n->onconflict = PG_IGNORE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 29287 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1286: /* CreateSchemaStmt: CREATE_P OR REPLACE SCHEMA qualified_name OptSchemaEltList */ + case 1289: #line 51 "third_party/libpg_query/grammar/statements/create_schema.y" - { + { PGCreateSchemaStmt *n = makeNode(PGCreateSchemaStmt); - if ((yyvsp[-1].range)->catalogname) { + if ((yyvsp[(5) - (6)].range)->catalogname) { ereport(ERROR, (errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("CREATE SCHEMA too many dots: expected \"catalog.schema\" or \"schema\""), - parser_errposition((yylsp[-1])))); + parser_errposition((yylsp[(5) - (6)])))); } - if ((yyvsp[-1].range)->schemaname) { - n->catalogname = (yyvsp[-1].range)->schemaname; - n->schemaname = (yyvsp[-1].range)->relname; + if ((yyvsp[(5) - (6)].range)->schemaname) { + n->catalogname = (yyvsp[(5) - (6)].range)->schemaname; + n->schemaname = (yyvsp[(5) - (6)].range)->relname; } else { - n->schemaname = (yyvsp[-1].range)->relname; + n->schemaname = (yyvsp[(5) - (6)].range)->relname; } - n->schemaElts = (yyvsp[0].list); + n->schemaElts = (yyvsp[(6) - (6)].list); n->onconflict = PG_REPLACE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 29310 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1287: /* OptSchemaEltList: OptSchemaEltList schema_stmt */ + case 1290: #line 74 "third_party/libpg_query/grammar/statements/create_schema.y" - { + { if ((yyloc) < 0) /* see comments for YYLLOC_DEFAULT */ - (yyloc) = (yylsp[0]); - (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); - } -#line 29320 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyloc) = (yylsp[(2) - (2)]); + (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); + ;} break; - case 1288: /* OptSchemaEltList: %empty */ + case 1291: #line 80 "third_party/libpg_query/grammar/statements/create_schema.y" - { (yyval.list) = NIL; } -#line 29326 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1293: /* IndexStmt: CREATE_P opt_unique INDEX opt_concurrently opt_index_name ON qualified_name access_method_clause '(' index_params ')' opt_reloptions where_clause */ + case 1296: #line 11 "third_party/libpg_query/grammar/statements/index.y" - { + { PGIndexStmt *n = makeNode(PGIndexStmt); - n->unique = (yyvsp[-11].boolean); - n->concurrent = (yyvsp[-9].boolean); - n->idxname = (yyvsp[-8].str); - n->relation = (yyvsp[-6].range); - n->accessMethod = (yyvsp[-5].str); - n->indexParams = (yyvsp[-3].list); - n->options = (yyvsp[-1].list); - n->whereClause = (yyvsp[0].node); + n->unique = (yyvsp[(2) - (13)].boolean); + n->concurrent = (yyvsp[(4) - (13)].boolean); + n->idxname = (yyvsp[(5) - (13)].str); + n->relation = (yyvsp[(7) - (13)].range); + n->accessMethod = (yyvsp[(8) - (13)].str); + n->indexParams = (yyvsp[(10) - (13)].list); + n->options = (yyvsp[(12) - (13)].list); + n->whereClause = (yyvsp[(13) - (13)].node); n->excludeOpNames = NIL; n->idxcomment = NULL; n->indexOid = InvalidOid; @@ -415864,22 +419243,21 @@ YYLTYPE yylloc = yyloc_default; n->transformed = false; n->onconflict = PG_ERROR_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 29353 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1294: /* IndexStmt: CREATE_P opt_unique INDEX opt_concurrently IF_P NOT EXISTS index_name ON qualified_name access_method_clause '(' index_params ')' opt_reloptions where_clause */ + case 1297: #line 36 "third_party/libpg_query/grammar/statements/index.y" - { + { PGIndexStmt *n = makeNode(PGIndexStmt); - n->unique = (yyvsp[-14].boolean); - n->concurrent = (yyvsp[-12].boolean); - n->idxname = (yyvsp[-8].str); - n->relation = (yyvsp[-6].range); - n->accessMethod = (yyvsp[-5].str); - n->indexParams = (yyvsp[-3].list); - n->options = (yyvsp[-1].list); - n->whereClause = (yyvsp[0].node); + n->unique = (yyvsp[(2) - (16)].boolean); + n->concurrent = (yyvsp[(4) - (16)].boolean); + n->idxname = (yyvsp[(8) - (16)].str); + n->relation = (yyvsp[(10) - (16)].range); + n->accessMethod = (yyvsp[(11) - (16)].str); + n->indexParams = (yyvsp[(13) - (16)].list); + n->options = (yyvsp[(15) - (16)].list); + n->whereClause = (yyvsp[(16) - (16)].node); n->excludeOpNames = NIL; n->idxcomment = NULL; n->indexOid = InvalidOid; @@ -415891,1601 +419269,1457 @@ YYLTYPE yylloc = yyloc_default; n->transformed = false; n->onconflict = PG_IGNORE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 29380 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1295: /* access_method: ColId */ + case 1298: #line 62 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29386 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1296: /* access_method_clause: USING access_method */ + case 1299: #line 66 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29392 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 1297: /* access_method_clause: %empty */ + case 1300: #line 67 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.str) = (char*) DEFAULT_INDEX_TYPE; } -#line 29398 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) DEFAULT_INDEX_TYPE; ;} break; - case 1298: /* opt_concurrently: CONCURRENTLY */ + case 1301: #line 72 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.boolean) = true; } -#line 29404 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1299: /* opt_concurrently: %empty */ + case 1302: #line 73 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.boolean) = false; } -#line 29410 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1300: /* opt_index_name: index_name */ + case 1303: #line 78 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29416 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1301: /* opt_index_name: %empty */ + case 1304: #line 79 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.str) = NULL; } -#line 29422 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 1302: /* opt_reloptions: WITH reloptions */ + case 1305: #line 83 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.list) = (yyvsp[0].list); } -#line 29428 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1303: /* opt_reloptions: %empty */ + case 1306: #line 84 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.list) = NIL; } -#line 29434 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1304: /* opt_unique: UNIQUE */ + case 1307: #line 89 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.boolean) = true; } -#line 29440 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1305: /* opt_unique: %empty */ + case 1308: #line 90 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.boolean) = false; } -#line 29446 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1306: /* AlterObjectSchemaStmt: ALTER TABLE relation_expr SET SCHEMA name */ + case 1309: #line 8 "third_party/libpg_query/grammar/statements/alter_schema.y" - { + { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); n->objectType = PG_OBJECT_TABLE; - n->relation = (yyvsp[-3].range); - n->newschema = (yyvsp[0].str); + n->relation = (yyvsp[(3) - (6)].range); + n->newschema = (yyvsp[(6) - (6)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 29459 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1307: /* AlterObjectSchemaStmt: ALTER TABLE IF_P EXISTS relation_expr SET SCHEMA name */ + case 1310: #line 17 "third_party/libpg_query/grammar/statements/alter_schema.y" - { + { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); n->objectType = PG_OBJECT_TABLE; - n->relation = (yyvsp[-3].range); - n->newschema = (yyvsp[0].str); + n->relation = (yyvsp[(5) - (8)].range); + n->newschema = (yyvsp[(8) - (8)].str); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 29472 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1308: /* AlterObjectSchemaStmt: ALTER SEQUENCE qualified_name SET SCHEMA name */ + case 1311: #line 26 "third_party/libpg_query/grammar/statements/alter_schema.y" - { + { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); n->objectType = PG_OBJECT_SEQUENCE; - n->relation = (yyvsp[-3].range); - n->newschema = (yyvsp[0].str); + n->relation = (yyvsp[(3) - (6)].range); + n->newschema = (yyvsp[(6) - (6)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 29485 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1309: /* AlterObjectSchemaStmt: ALTER SEQUENCE IF_P EXISTS qualified_name SET SCHEMA name */ + case 1312: #line 35 "third_party/libpg_query/grammar/statements/alter_schema.y" - { + { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); n->objectType = PG_OBJECT_SEQUENCE; - n->relation = (yyvsp[-3].range); - n->newschema = (yyvsp[0].str); + n->relation = (yyvsp[(5) - (8)].range); + n->newschema = (yyvsp[(8) - (8)].str); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 29498 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1310: /* AlterObjectSchemaStmt: ALTER VIEW qualified_name SET SCHEMA name */ + case 1313: #line 44 "third_party/libpg_query/grammar/statements/alter_schema.y" - { + { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); n->objectType = PG_OBJECT_VIEW; - n->relation = (yyvsp[-3].range); - n->newschema = (yyvsp[0].str); + n->relation = (yyvsp[(3) - (6)].range); + n->newschema = (yyvsp[(6) - (6)].str); n->missing_ok = false; (yyval.node) = (PGNode *)n; - } -#line 29511 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1311: /* AlterObjectSchemaStmt: ALTER VIEW IF_P EXISTS qualified_name SET SCHEMA name */ + case 1314: #line 53 "third_party/libpg_query/grammar/statements/alter_schema.y" - { + { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); n->objectType = PG_OBJECT_VIEW; - n->relation = (yyvsp[-3].range); - n->newschema = (yyvsp[0].str); + n->relation = (yyvsp[(5) - (8)].range); + n->newschema = (yyvsp[(8) - (8)].str); n->missing_ok = true; (yyval.node) = (PGNode *)n; - } -#line 29524 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1312: /* CheckPointStmt: FORCE CHECKPOINT opt_col_id */ + case 1315: #line 6 "third_party/libpg_query/grammar/statements/checkpoint.y" - { + { PGCheckPointStmt *n = makeNode(PGCheckPointStmt); n->force = true; - n->name = (yyvsp[0].str); + n->name = (yyvsp[(3) - (3)].str); (yyval.node) = (PGNode *)n; - } -#line 29535 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1313: /* CheckPointStmt: CHECKPOINT opt_col_id */ + case 1316: #line 13 "third_party/libpg_query/grammar/statements/checkpoint.y" - { + { PGCheckPointStmt *n = makeNode(PGCheckPointStmt); n->force = false; - n->name = (yyvsp[0].str); + n->name = (yyvsp[(2) - (2)].str); (yyval.node) = (PGNode *)n; - } -#line 29546 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1314: /* opt_col_id: ColId */ + case 1317: #line 22 "third_party/libpg_query/grammar/statements/checkpoint.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29552 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1315: /* opt_col_id: %empty */ + case 1318: #line 23 "third_party/libpg_query/grammar/statements/checkpoint.y" - { (yyval.str) = NULL; } -#line 29558 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 1316: /* CommentOnStmt: COMMENT ON comment_on_type_any_name qualified_name IS comment_value */ + case 1319: #line 8 "third_party/libpg_query/grammar/statements/comment_on.y" - { + { PGCommentOnStmt *n = makeNode(PGCommentOnStmt); - n->object_type = (yyvsp[-3].objtype); - n->name = (yyvsp[-2].range); - n->value = (yyvsp[0].node); + n->object_type = (yyvsp[(3) - (6)].objtype); + n->name = (yyvsp[(4) - (6)].range); + n->value = (yyvsp[(6) - (6)].node); (yyval.node) = (PGNode *)n; - } -#line 29570 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1317: /* CommentOnStmt: COMMENT ON COLUMN a_expr IS comment_value */ + case 1320: #line 16 "third_party/libpg_query/grammar/statements/comment_on.y" - { + { PGCommentOnStmt *n = makeNode(PGCommentOnStmt); n->object_type = PG_OBJECT_COLUMN; - n->column_expr = (yyvsp[-2].node); - n->value = (yyvsp[0].node); + n->column_expr = (yyvsp[(4) - (6)].node); + n->value = (yyvsp[(6) - (6)].node); (yyval.node) = (PGNode *)n; - } -#line 29582 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1318: /* comment_value: Sconst */ + case 1321: #line 26 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.node) = makeStringConst((yyvsp[0].str), (yylsp[0])); } -#line 29588 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; - case 1319: /* comment_value: NULL_P */ + case 1322: #line 27 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.node) = makeNullAConst((yylsp[0])); } -#line 29594 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeNullAConst((yylsp[(1) - (1)])); ;} break; - case 1320: /* comment_on_type_any_name: TABLE */ + case 1323: #line 30 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_TABLE; } -#line 29600 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TABLE; ;} break; - case 1321: /* comment_on_type_any_name: SEQUENCE */ + case 1324: #line 31 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_SEQUENCE; } -#line 29606 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_SEQUENCE; ;} break; - case 1322: /* comment_on_type_any_name: FUNCTION */ + case 1325: #line 32 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_FUNCTION; } -#line 29612 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 1323: /* comment_on_type_any_name: MACRO */ + case 1326: #line 33 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_FUNCTION; } -#line 29618 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 1324: /* comment_on_type_any_name: MACRO TABLE */ + case 1327: #line 34 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; } -#line 29624 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; ;} break; - case 1325: /* comment_on_type_any_name: VIEW */ + case 1328: #line 35 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_VIEW; } -#line 29630 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_VIEW; ;} break; - case 1326: /* comment_on_type_any_name: DATABASE */ + case 1329: #line 36 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_DATABASE; } -#line 29636 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_DATABASE; ;} break; - case 1327: /* comment_on_type_any_name: INDEX */ + case 1330: #line 37 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_INDEX; } -#line 29642 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_INDEX; ;} break; - case 1328: /* comment_on_type_any_name: SCHEMA */ + case 1331: #line 38 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_SCHEMA; } -#line 29648 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_SCHEMA; ;} break; - case 1329: /* comment_on_type_any_name: TYPE_P */ + case 1332: #line 39 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_TYPE; } -#line 29654 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TYPE; ;} break; - case 1330: /* ExportStmt: EXPORT_P DATABASE Sconst copy_options */ + case 1333: #line 8 "third_party/libpg_query/grammar/statements/export.y" - { + { PGExportStmt *n = makeNode(PGExportStmt); n->database = NULL; - n->filename = (yyvsp[-1].str); + n->filename = (yyvsp[(3) - (4)].str); n->options = NIL; - if ((yyvsp[0].list)) { - n->options = list_concat(n->options, (yyvsp[0].list)); + if ((yyvsp[(4) - (4)].list)) { + n->options = list_concat(n->options, (yyvsp[(4) - (4)].list)); } (yyval.node) = (PGNode *)n; - } -#line 29669 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1331: /* ExportStmt: EXPORT_P DATABASE ColId TO Sconst copy_options */ + case 1334: #line 20 "third_party/libpg_query/grammar/statements/export.y" - { + { PGExportStmt *n = makeNode(PGExportStmt); - n->database = (yyvsp[-3].str); - n->filename = (yyvsp[-1].str); + n->database = (yyvsp[(3) - (6)].str); + n->filename = (yyvsp[(5) - (6)].str); n->options = NIL; - if ((yyvsp[0].list)) { - n->options = list_concat(n->options, (yyvsp[0].list)); + if ((yyvsp[(6) - (6)].list)) { + n->options = list_concat(n->options, (yyvsp[(6) - (6)].list)); } (yyval.node) = (PGNode *)n; - } -#line 29684 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1332: /* ImportStmt: IMPORT_P DATABASE Sconst */ + case 1335: #line 34 "third_party/libpg_query/grammar/statements/export.y" - { + { PGImportStmt *n = makeNode(PGImportStmt); - n->filename = (yyvsp[0].str); + n->filename = (yyvsp[(3) - (3)].str); (yyval.node) = (PGNode *)n; - } -#line 29694 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1333: /* ExplainStmt: EXPLAIN ExplainableStmt */ + case 1336: #line 10 "third_party/libpg_query/grammar/statements/explain.y" - { + { PGExplainStmt *n = makeNode(PGExplainStmt); - n->query = (yyvsp[0].node); + n->query = (yyvsp[(2) - (2)].node); n->options = NIL; (yyval.node) = (PGNode *) n; - } -#line 29705 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1334: /* ExplainStmt: EXPLAIN analyze_keyword opt_verbose ExplainableStmt */ + case 1337: #line 17 "third_party/libpg_query/grammar/statements/explain.y" - { + { PGExplainStmt *n = makeNode(PGExplainStmt); - n->query = (yyvsp[0].node); - n->options = list_make1(makeDefElem("analyze", NULL, (yylsp[-2]))); - if ((yyvsp[-1].boolean)) + n->query = (yyvsp[(4) - (4)].node); + n->options = list_make1(makeDefElem("analyze", NULL, (yylsp[(2) - (4)]))); + if ((yyvsp[(3) - (4)].boolean)) n->options = lappend(n->options, - makeDefElem("verbose", NULL, (yylsp[-1]))); + makeDefElem("verbose", NULL, (yylsp[(3) - (4)]))); (yyval.node) = (PGNode *) n; - } -#line 29719 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1335: /* ExplainStmt: EXPLAIN VERBOSE ExplainableStmt */ + case 1338: #line 27 "third_party/libpg_query/grammar/statements/explain.y" - { + { PGExplainStmt *n = makeNode(PGExplainStmt); - n->query = (yyvsp[0].node); - n->options = list_make1(makeDefElem("verbose", NULL, (yylsp[-1]))); + n->query = (yyvsp[(3) - (3)].node); + n->options = list_make1(makeDefElem("verbose", NULL, (yylsp[(2) - (3)]))); (yyval.node) = (PGNode *) n; - } -#line 29730 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1336: /* ExplainStmt: EXPLAIN '(' explain_option_list ')' ExplainableStmt */ + case 1339: #line 34 "third_party/libpg_query/grammar/statements/explain.y" - { + { PGExplainStmt *n = makeNode(PGExplainStmt); - n->query = (yyvsp[0].node); - n->options = (yyvsp[-2].list); + n->query = (yyvsp[(5) - (5)].node); + n->options = (yyvsp[(3) - (5)].list); (yyval.node) = (PGNode *) n; - } -#line 29741 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1337: /* opt_verbose: VERBOSE */ + case 1340: #line 44 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.boolean) = true; } -#line 29747 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1338: /* opt_verbose: %empty */ + case 1341: #line 45 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.boolean) = false; } -#line 29753 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1339: /* explain_option_arg: opt_boolean_or_string */ + case 1342: #line 50 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); } -#line 29759 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;} break; - case 1340: /* explain_option_arg: NumericOnly */ + case 1343: #line 51 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.node) = (PGNode *) (yyvsp[0].value); } -#line 29765 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].value); ;} break; - case 1341: /* explain_option_arg: %empty */ + case 1344: #line 52 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.node) = NULL; } -#line 29771 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1372: /* NonReservedWord: IDENT */ + case 1375: #line 90 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29777 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1373: /* NonReservedWord: unreserved_keyword */ + case 1376: #line 91 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29783 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1374: /* NonReservedWord: other_keyword */ + case 1377: #line 92 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29789 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1375: /* NonReservedWord_or_Sconst: NonReservedWord */ + case 1378: #line 97 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29795 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1376: /* NonReservedWord_or_Sconst: Sconst */ + case 1379: #line 98 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29801 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1377: /* explain_option_list: explain_option_elem */ + case 1380: #line 104 "third_party/libpg_query/grammar/statements/explain.y" - { - (yyval.list) = list_make1((yyvsp[0].defelt)); - } -#line 29809 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); + ;} break; - case 1378: /* explain_option_list: explain_option_list ',' explain_option_elem */ + case 1381: #line 108 "third_party/libpg_query/grammar/statements/explain.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt)); - } -#line 29817 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); + ;} break; - case 1379: /* analyze_keyword: ANALYZE */ + case 1382: #line 115 "third_party/libpg_query/grammar/statements/explain.y" - {} -#line 29823 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 1380: /* analyze_keyword: ANALYSE */ + case 1383: #line 116 "third_party/libpg_query/grammar/statements/explain.y" - {} -#line 29829 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 1381: /* opt_boolean_or_string: TRUE_P */ + case 1384: #line 121 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (char*) "true"; } -#line 29835 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "true"; ;} break; - case 1382: /* opt_boolean_or_string: FALSE_P */ + case 1385: #line 122 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (char*) "false"; } -#line 29841 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "false"; ;} break; - case 1383: /* opt_boolean_or_string: ON */ + case 1386: #line 123 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (char*) "on"; } -#line 29847 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "on"; ;} break; - case 1384: /* opt_boolean_or_string: NonReservedWord_or_Sconst */ + case 1387: #line 129 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29853 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1385: /* explain_option_elem: explain_option_name explain_option_arg */ + case 1388: #line 135 "third_party/libpg_query/grammar/statements/explain.y" - { - (yyval.defelt) = makeDefElem((yyvsp[-1].str), (yyvsp[0].node), (yylsp[-1])); - } -#line 29861 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); + ;} break; - case 1386: /* explain_option_name: NonReservedWord */ + case 1389: #line 142 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29867 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1387: /* explain_option_name: analyze_keyword */ + case 1390: #line 143 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (char*) "analyze"; } -#line 29873 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "analyze"; ;} break; - case 1388: /* VariableSetStmt: SET set_rest */ + case 1391: #line 11 "third_party/libpg_query/grammar/statements/variable_set.y" - { - PGVariableSetStmt *n = (yyvsp[0].vsetstmt); + { + PGVariableSetStmt *n = (yyvsp[(2) - (2)].vsetstmt); n->scope = VAR_SET_SCOPE_DEFAULT; (yyval.node) = (PGNode *) n; - } -#line 29883 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1389: /* VariableSetStmt: SET LOCAL set_rest */ + case 1392: #line 17 "third_party/libpg_query/grammar/statements/variable_set.y" - { - PGVariableSetStmt *n = (yyvsp[0].vsetstmt); + { + PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt); n->scope = VAR_SET_SCOPE_LOCAL; (yyval.node) = (PGNode *) n; - } -#line 29893 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1390: /* VariableSetStmt: SET SESSION set_rest */ + case 1393: #line 23 "third_party/libpg_query/grammar/statements/variable_set.y" - { - PGVariableSetStmt *n = (yyvsp[0].vsetstmt); + { + PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt); n->scope = VAR_SET_SCOPE_SESSION; (yyval.node) = (PGNode *) n; - } -#line 29903 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1391: /* VariableSetStmt: SET GLOBAL set_rest */ + case 1394: #line 29 "third_party/libpg_query/grammar/statements/variable_set.y" - { - PGVariableSetStmt *n = (yyvsp[0].vsetstmt); + { + PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt); n->scope = VAR_SET_SCOPE_GLOBAL; (yyval.node) = (PGNode *) n; - } -#line 29913 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1392: /* set_rest: generic_set */ + case 1395: #line 38 "third_party/libpg_query/grammar/statements/variable_set.y" - {(yyval.vsetstmt) = (yyvsp[0].vsetstmt);} -#line 29919 "third_party/libpg_query/grammar/grammar_out.cpp" + {(yyval.vsetstmt) = (yyvsp[(1) - (1)].vsetstmt);;} break; - case 1393: /* set_rest: var_name FROM CURRENT_P */ + case 1396: #line 40 "third_party/libpg_query/grammar/statements/variable_set.y" - { + { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); n->kind = VAR_SET_CURRENT; - n->name = (yyvsp[-2].str); + n->name = (yyvsp[(1) - (3)].str); (yyval.vsetstmt) = n; - } -#line 29930 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1394: /* set_rest: TIME ZONE zone_value */ + case 1397: #line 48 "third_party/libpg_query/grammar/statements/variable_set.y" - { + { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); n->kind = VAR_SET_VALUE; n->name = (char*) "timezone"; - if ((yyvsp[0].node) != NULL) - n->args = list_make1((yyvsp[0].node)); + if ((yyvsp[(3) - (3)].node) != NULL) + n->args = list_make1((yyvsp[(3) - (3)].node)); else n->kind = VAR_SET_DEFAULT; (yyval.vsetstmt) = n; - } -#line 29945 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1395: /* set_rest: SCHEMA Sconst */ + case 1398: #line 59 "third_party/libpg_query/grammar/statements/variable_set.y" - { + { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); n->kind = VAR_SET_VALUE; n->name = (char*) "search_path"; - n->args = list_make1(makeStringConst((yyvsp[0].str), (yylsp[0]))); + n->args = list_make1(makeStringConst((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)]))); (yyval.vsetstmt) = n; - } -#line 29957 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1396: /* generic_set: var_name TO var_list */ + case 1399: #line 71 "third_party/libpg_query/grammar/statements/variable_set.y" - { + { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); n->kind = VAR_SET_VALUE; - n->name = (yyvsp[-2].str); - n->args = (yyvsp[0].list); + n->name = (yyvsp[(1) - (3)].str); + n->args = (yyvsp[(3) - (3)].list); (yyval.vsetstmt) = n; - } -#line 29969 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1397: /* generic_set: var_name '=' var_list */ + case 1400: #line 79 "third_party/libpg_query/grammar/statements/variable_set.y" - { + { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); n->kind = VAR_SET_VALUE; - n->name = (yyvsp[-2].str); - n->args = (yyvsp[0].list); + n->name = (yyvsp[(1) - (3)].str); + n->args = (yyvsp[(3) - (3)].list); (yyval.vsetstmt) = n; - } -#line 29981 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1398: /* var_value: a_expr */ + case 1401: #line 90 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.node) = (yyvsp[0].node); } -#line 29987 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1399: /* zone_value: Sconst */ + case 1402: #line 96 "third_party/libpg_query/grammar/statements/variable_set.y" - { - (yyval.node) = makeStringConst((yyvsp[0].str), (yylsp[0])); - } -#line 29995 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 1400: /* zone_value: IDENT */ + case 1403: #line 100 "third_party/libpg_query/grammar/statements/variable_set.y" - { - (yyval.node) = makeStringConst((yyvsp[0].str), (yylsp[0])); - } -#line 30003 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 1401: /* zone_value: ConstInterval Sconst opt_interval */ + case 1404: #line 104 "third_party/libpg_query/grammar/statements/variable_set.y" - { - PGTypeName *t = (yyvsp[-2].typnam); - if ((yyvsp[0].list) != NIL) + { + PGTypeName *t = (yyvsp[(1) - (3)].typnam); + if ((yyvsp[(3) - (3)].list) != NIL) { - PGAConst *n = (PGAConst *) linitial((yyvsp[0].list)); + PGAConst *n = (PGAConst *) linitial((yyvsp[(3) - (3)].list)); if ((n->val.val.ival & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0) ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("time zone interval must be HOUR or HOUR TO MINUTE"), - parser_errposition((yylsp[0])))); + parser_errposition((yylsp[(3) - (3)])))); } - t->typmods = (yyvsp[0].list); - (yyval.node) = makeStringConstCast((yyvsp[-1].str), (yylsp[-1]), t); - } -#line 30022 "third_party/libpg_query/grammar/grammar_out.cpp" + t->typmods = (yyvsp[(3) - (3)].list); + (yyval.node) = makeStringConstCast((yyvsp[(2) - (3)].str), (yylsp[(2) - (3)]), t); + ;} break; - case 1402: /* zone_value: ConstInterval '(' Iconst ')' Sconst */ + case 1405: #line 119 "third_party/libpg_query/grammar/statements/variable_set.y" - { - PGTypeName *t = (yyvsp[-4].typnam); + { + PGTypeName *t = (yyvsp[(1) - (5)].typnam); t->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1), - makeIntConst((yyvsp[-2].ival), (yylsp[-2]))); - (yyval.node) = makeStringConstCast((yyvsp[0].str), (yylsp[0]), t); - } -#line 30033 "third_party/libpg_query/grammar/grammar_out.cpp" + makeIntConst((yyvsp[(3) - (5)].ival), (yylsp[(3) - (5)]))); + (yyval.node) = makeStringConstCast((yyvsp[(5) - (5)].str), (yylsp[(5) - (5)]), t); + ;} break; - case 1403: /* zone_value: NumericOnly */ + case 1406: #line 125 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.node) = makeAConst((yyvsp[0].value), (yylsp[0])); } -#line 30039 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeAConst((yyvsp[(1) - (1)].value), (yylsp[(1) - (1)])); ;} break; - case 1404: /* zone_value: DEFAULT */ + case 1407: #line 126 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.node) = NULL; } -#line 30045 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1405: /* zone_value: LOCAL */ + case 1408: #line 127 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.node) = NULL; } -#line 30051 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1406: /* var_list: var_value */ + case 1409: #line 131 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 30057 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1407: /* var_list: var_list ',' var_value */ + case 1410: #line 132 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 30063 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 1408: /* LoadStmt: LOAD file_name */ + case 1411: #line 8 "third_party/libpg_query/grammar/statements/load.y" - { + { PGLoadStmt *n = makeNode(PGLoadStmt); - n->filename = (yyvsp[0].str); + n->filename = (yyvsp[(2) - (2)].str); n->repository = ""; n->load_type = PG_LOAD_TYPE_LOAD; (yyval.node) = (PGNode *)n; - } -#line 30075 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1409: /* LoadStmt: INSTALL file_name */ + case 1412: #line 15 "third_party/libpg_query/grammar/statements/load.y" - { + { PGLoadStmt *n = makeNode(PGLoadStmt); - n->filename = (yyvsp[0].str); + n->filename = (yyvsp[(2) - (2)].str); n->repository = ""; n->load_type = PG_LOAD_TYPE_INSTALL; (yyval.node) = (PGNode *)n; - } -#line 30087 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1410: /* LoadStmt: FORCE INSTALL file_name */ + case 1413: #line 22 "third_party/libpg_query/grammar/statements/load.y" - { + { PGLoadStmt *n = makeNode(PGLoadStmt); - n->filename = (yyvsp[0].str); + n->filename = (yyvsp[(3) - (3)].str); n->repository = ""; n->load_type = PG_LOAD_TYPE_FORCE_INSTALL; (yyval.node) = (PGNode *)n; - } -#line 30099 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1411: /* LoadStmt: INSTALL file_name FROM repo_path */ + case 1414: #line 29 "third_party/libpg_query/grammar/statements/load.y" - { + { PGLoadStmt *n = makeNode(PGLoadStmt); - n->filename = (yyvsp[-2].str); - n->repository = (yyvsp[0].str); + n->filename = (yyvsp[(2) - (4)].str); + n->repository = (yyvsp[(4) - (4)].str); n->load_type = PG_LOAD_TYPE_INSTALL; (yyval.node) = (PGNode *)n; - } -#line 30111 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1412: /* LoadStmt: FORCE INSTALL file_name FROM repo_path */ + case 1415: #line 36 "third_party/libpg_query/grammar/statements/load.y" - { + { PGLoadStmt *n = makeNode(PGLoadStmt); - n->filename = (yyvsp[-2].str); - n->repository = (yyvsp[0].str); + n->filename = (yyvsp[(3) - (5)].str); + n->repository = (yyvsp[(5) - (5)].str); n->load_type = PG_LOAD_TYPE_FORCE_INSTALL; (yyval.node) = (PGNode *)n; - } -#line 30123 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1413: /* file_name: Sconst */ + case 1416: #line 45 "third_party/libpg_query/grammar/statements/load.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30129 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1414: /* file_name: ColId */ + case 1417: #line 46 "third_party/libpg_query/grammar/statements/load.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30135 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1415: /* repo_path: Sconst */ + case 1418: #line 48 "third_party/libpg_query/grammar/statements/load.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30141 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1416: /* repo_path: ColId */ + case 1419: #line 49 "third_party/libpg_query/grammar/statements/load.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30147 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1417: /* VacuumStmt: VACUUM opt_full opt_freeze opt_verbose */ + case 1420: #line 9 "third_party/libpg_query/grammar/statements/vacuum.y" - { + { PGVacuumStmt *n = makeNode(PGVacuumStmt); n->options = PG_VACOPT_VACUUM; - if ((yyvsp[-2].boolean)) + if ((yyvsp[(2) - (4)].boolean)) n->options |= PG_VACOPT_FULL; - if ((yyvsp[-1].boolean)) + if ((yyvsp[(3) - (4)].boolean)) n->options |= PG_VACOPT_FREEZE; - if ((yyvsp[0].boolean)) + if ((yyvsp[(4) - (4)].boolean)) n->options |= PG_VACOPT_VERBOSE; n->relation = NULL; n->va_cols = NIL; (yyval.node) = (PGNode *)n; - } -#line 30165 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1418: /* VacuumStmt: VACUUM opt_full opt_freeze opt_verbose qualified_name opt_name_list */ + case 1421: #line 23 "third_party/libpg_query/grammar/statements/vacuum.y" - { + { PGVacuumStmt *n = makeNode(PGVacuumStmt); n->options = PG_VACOPT_VACUUM; - if ((yyvsp[-4].boolean)) + if ((yyvsp[(2) - (6)].boolean)) n->options |= PG_VACOPT_FULL; - if ((yyvsp[-3].boolean)) + if ((yyvsp[(3) - (6)].boolean)) n->options |= PG_VACOPT_FREEZE; - if ((yyvsp[-2].boolean)) + if ((yyvsp[(4) - (6)].boolean)) n->options |= PG_VACOPT_VERBOSE; - n->relation = (yyvsp[-1].range); - n->va_cols = (yyvsp[0].list); + n->relation = (yyvsp[(5) - (6)].range); + n->va_cols = (yyvsp[(6) - (6)].list); (yyval.node) = (PGNode *)n; - } -#line 30183 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1419: /* VacuumStmt: VACUUM opt_full opt_freeze opt_verbose AnalyzeStmt */ + case 1422: #line 37 "third_party/libpg_query/grammar/statements/vacuum.y" - { - PGVacuumStmt *n = (PGVacuumStmt *) (yyvsp[0].node); + { + PGVacuumStmt *n = (PGVacuumStmt *) (yyvsp[(5) - (5)].node); n->options |= PG_VACOPT_VACUUM; - if ((yyvsp[-3].boolean)) + if ((yyvsp[(2) - (5)].boolean)) n->options |= PG_VACOPT_FULL; - if ((yyvsp[-2].boolean)) + if ((yyvsp[(3) - (5)].boolean)) n->options |= PG_VACOPT_FREEZE; - if ((yyvsp[-1].boolean)) + if ((yyvsp[(4) - (5)].boolean)) n->options |= PG_VACOPT_VERBOSE; (yyval.node) = (PGNode *)n; - } -#line 30199 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1420: /* VacuumStmt: VACUUM '(' vacuum_option_list ')' */ + case 1423: #line 49 "third_party/libpg_query/grammar/statements/vacuum.y" - { + { PGVacuumStmt *n = makeNode(PGVacuumStmt); - n->options = PG_VACOPT_VACUUM | (yyvsp[-1].ival); + n->options = PG_VACOPT_VACUUM | (yyvsp[(3) - (4)].ival); n->relation = NULL; n->va_cols = NIL; (yyval.node) = (PGNode *) n; - } -#line 30211 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1421: /* VacuumStmt: VACUUM '(' vacuum_option_list ')' qualified_name opt_name_list */ + case 1424: #line 57 "third_party/libpg_query/grammar/statements/vacuum.y" - { + { PGVacuumStmt *n = makeNode(PGVacuumStmt); - n->options = PG_VACOPT_VACUUM | (yyvsp[-3].ival); - n->relation = (yyvsp[-1].range); - n->va_cols = (yyvsp[0].list); + n->options = PG_VACOPT_VACUUM | (yyvsp[(3) - (6)].ival); + n->relation = (yyvsp[(5) - (6)].range); + n->va_cols = (yyvsp[(6) - (6)].list); if (n->va_cols != NIL) /* implies analyze */ n->options |= PG_VACOPT_ANALYZE; (yyval.node) = (PGNode *) n; - } -#line 30225 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1422: /* vacuum_option_elem: analyze_keyword */ + case 1425: #line 70 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = PG_VACOPT_ANALYZE; } -#line 30231 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_VACOPT_ANALYZE; ;} break; - case 1423: /* vacuum_option_elem: VERBOSE */ + case 1426: #line 71 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = PG_VACOPT_VERBOSE; } -#line 30237 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_VACOPT_VERBOSE; ;} break; - case 1424: /* vacuum_option_elem: FREEZE */ + case 1427: #line 72 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = PG_VACOPT_FREEZE; } -#line 30243 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_VACOPT_FREEZE; ;} break; - case 1425: /* vacuum_option_elem: FULL */ + case 1428: #line 73 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = PG_VACOPT_FULL; } -#line 30249 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_VACOPT_FULL; ;} break; - case 1426: /* vacuum_option_elem: IDENT */ + case 1429: #line 75 "third_party/libpg_query/grammar/statements/vacuum.y" - { - if (strcmp((yyvsp[0].str), "disable_page_skipping") == 0) + { + if (strcmp((yyvsp[(1) - (1)].str), "disable_page_skipping") == 0) (yyval.ival) = PG_VACOPT_DISABLE_PAGE_SKIPPING; else ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), - errmsg("unrecognized VACUUM option \"%s\"", (yyvsp[0].str)), - parser_errposition((yylsp[0])))); - } -#line 30263 "third_party/libpg_query/grammar/grammar_out.cpp" + errmsg("unrecognized VACUUM option \"%s\"", (yyvsp[(1) - (1)].str)), + parser_errposition((yylsp[(1) - (1)])))); + ;} break; - case 1427: /* opt_full: FULL */ + case 1430: #line 87 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.boolean) = true; } -#line 30269 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1428: /* opt_full: %empty */ + case 1431: #line 88 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.boolean) = false; } -#line 30275 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1429: /* vacuum_option_list: vacuum_option_elem */ + case 1432: #line 93 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = (yyvsp[0].ival); } -#line 30281 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} break; - case 1430: /* vacuum_option_list: vacuum_option_list ',' vacuum_option_elem */ + case 1433: #line 94 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = (yyvsp[-2].ival) | (yyvsp[0].ival); } -#line 30287 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;} break; - case 1431: /* opt_freeze: FREEZE */ + case 1434: #line 98 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.boolean) = true; } -#line 30293 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1432: /* opt_freeze: %empty */ + case 1435: #line 99 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.boolean) = false; } -#line 30299 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1433: /* DeleteStmt: opt_with_clause DELETE_P FROM relation_expr_opt_alias using_clause where_or_current_clause returning_clause */ + case 1436: #line 9 "third_party/libpg_query/grammar/statements/delete.y" - { + { PGDeleteStmt *n = makeNode(PGDeleteStmt); - n->relation = (yyvsp[-3].range); - n->usingClause = (yyvsp[-2].list); - n->whereClause = (yyvsp[-1].node); - n->returningList = (yyvsp[0].list); - n->withClause = (yyvsp[-6].with); + n->relation = (yyvsp[(4) - (7)].range); + n->usingClause = (yyvsp[(5) - (7)].list); + n->whereClause = (yyvsp[(6) - (7)].node); + n->returningList = (yyvsp[(7) - (7)].list); + n->withClause = (yyvsp[(1) - (7)].with); (yyval.node) = (PGNode *)n; - } -#line 30313 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1434: /* DeleteStmt: TRUNCATE opt_table relation_expr_opt_alias */ + case 1437: #line 19 "third_party/libpg_query/grammar/statements/delete.y" - { + { PGDeleteStmt *n = makeNode(PGDeleteStmt); - n->relation = (yyvsp[0].range); + n->relation = (yyvsp[(3) - (3)].range); n->usingClause = NULL; n->whereClause = NULL; n->returningList = NULL; n->withClause = NULL; (yyval.node) = (PGNode *)n; - } -#line 30327 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1435: /* relation_expr_opt_alias: relation_expr */ + case 1438: #line 32 "third_party/libpg_query/grammar/statements/delete.y" - { - (yyval.range) = (yyvsp[0].range); - } -#line 30335 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.range) = (yyvsp[(1) - (1)].range); + ;} break; - case 1436: /* relation_expr_opt_alias: relation_expr ColId */ + case 1439: #line 36 "third_party/libpg_query/grammar/statements/delete.y" - { + { PGAlias *alias = makeNode(PGAlias); - alias->aliasname = (yyvsp[0].str); - (yyvsp[-1].range)->alias = alias; - (yyval.range) = (yyvsp[-1].range); - } -#line 30346 "third_party/libpg_query/grammar/grammar_out.cpp" + alias->aliasname = (yyvsp[(2) - (2)].str); + (yyvsp[(1) - (2)].range)->alias = alias; + (yyval.range) = (yyvsp[(1) - (2)].range); + ;} break; - case 1437: /* relation_expr_opt_alias: relation_expr AS ColId */ + case 1440: #line 43 "third_party/libpg_query/grammar/statements/delete.y" - { + { PGAlias *alias = makeNode(PGAlias); - alias->aliasname = (yyvsp[0].str); - (yyvsp[-2].range)->alias = alias; - (yyval.range) = (yyvsp[-2].range); - } -#line 30357 "third_party/libpg_query/grammar/grammar_out.cpp" + alias->aliasname = (yyvsp[(3) - (3)].str); + (yyvsp[(1) - (3)].range)->alias = alias; + (yyval.range) = (yyvsp[(1) - (3)].range); + ;} break; - case 1438: /* where_or_current_clause: WHERE a_expr */ + case 1441: #line 53 "third_party/libpg_query/grammar/statements/delete.y" - { (yyval.node) = (yyvsp[0].node); } -#line 30363 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1439: /* where_or_current_clause: %empty */ + case 1442: #line 54 "third_party/libpg_query/grammar/statements/delete.y" - { (yyval.node) = NULL; } -#line 30369 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1440: /* using_clause: USING from_list_opt_comma */ + case 1443: #line 60 "third_party/libpg_query/grammar/statements/delete.y" - { (yyval.list) = (yyvsp[0].list); } -#line 30375 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1441: /* using_clause: %empty */ + case 1444: #line 61 "third_party/libpg_query/grammar/statements/delete.y" - { (yyval.list) = NIL; } -#line 30381 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1442: /* AnalyzeStmt: analyze_keyword opt_verbose */ + case 1445: #line 10 "third_party/libpg_query/grammar/statements/analyze.y" - { + { PGVacuumStmt *n = makeNode(PGVacuumStmt); n->options = PG_VACOPT_ANALYZE; - if ((yyvsp[0].boolean)) + if ((yyvsp[(2) - (2)].boolean)) n->options |= PG_VACOPT_VERBOSE; n->relation = NULL; n->va_cols = NIL; (yyval.node) = (PGNode *)n; - } -#line 30395 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1443: /* AnalyzeStmt: analyze_keyword opt_verbose qualified_name opt_name_list */ + case 1446: #line 20 "third_party/libpg_query/grammar/statements/analyze.y" - { + { PGVacuumStmt *n = makeNode(PGVacuumStmt); n->options = PG_VACOPT_ANALYZE; - if ((yyvsp[-2].boolean)) + if ((yyvsp[(2) - (4)].boolean)) n->options |= PG_VACOPT_VERBOSE; - n->relation = (yyvsp[-1].range); - n->va_cols = (yyvsp[0].list); + n->relation = (yyvsp[(3) - (4)].range); + n->va_cols = (yyvsp[(4) - (4)].list); (yyval.node) = (PGNode *)n; - } -#line 30409 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1444: /* AttachStmt: ATTACH opt_database Sconst opt_database_alias copy_options */ + case 1447: #line 8 "third_party/libpg_query/grammar/statements/attach.y" - { + { PGAttachStmt *n = makeNode(PGAttachStmt); - n->path = (yyvsp[-2].str); - n->name = (yyvsp[-1].str); - n->options = (yyvsp[0].list); + n->path = (yyvsp[(3) - (5)].str); + n->name = (yyvsp[(4) - (5)].str); + n->options = (yyvsp[(5) - (5)].list); n->onconflict = PG_ERROR_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 30422 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1445: /* AttachStmt: ATTACH IF_P NOT EXISTS opt_database Sconst opt_database_alias copy_options */ + case 1448: #line 17 "third_party/libpg_query/grammar/statements/attach.y" - { + { PGAttachStmt *n = makeNode(PGAttachStmt); - n->path = (yyvsp[-2].str); - n->name = (yyvsp[-1].str); - n->options = (yyvsp[0].list); + n->path = (yyvsp[(6) - (8)].str); + n->name = (yyvsp[(7) - (8)].str); + n->options = (yyvsp[(8) - (8)].list); n->onconflict = PG_IGNORE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 30435 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1446: /* DetachStmt: DETACH ColLabel */ + case 1449: #line 29 "third_party/libpg_query/grammar/statements/attach.y" - { + { PGDetachStmt *n = makeNode(PGDetachStmt); n->missing_ok = false; - n->db_name = (yyvsp[0].str); + n->db_name = (yyvsp[(2) - (2)].str); (yyval.node) = (PGNode *)n; - } -#line 30446 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1447: /* DetachStmt: DETACH DATABASE ColLabel */ + case 1450: #line 36 "third_party/libpg_query/grammar/statements/attach.y" - { + { PGDetachStmt *n = makeNode(PGDetachStmt); n->missing_ok = false; - n->db_name = (yyvsp[0].str); + n->db_name = (yyvsp[(3) - (3)].str); (yyval.node) = (PGNode *)n; - } -#line 30457 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1448: /* DetachStmt: DETACH DATABASE IF_P EXISTS ColLabel */ + case 1451: #line 43 "third_party/libpg_query/grammar/statements/attach.y" - { + { PGDetachStmt *n = makeNode(PGDetachStmt); n->missing_ok = true; - n->db_name = (yyvsp[0].str); + n->db_name = (yyvsp[(5) - (5)].str); (yyval.node) = (PGNode *)n; - } -#line 30468 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1449: /* opt_database: DATABASE */ + case 1452: #line 51 "third_party/libpg_query/grammar/statements/attach.y" - {} -#line 30474 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 1450: /* opt_database: %empty */ + case 1453: #line 52 "third_party/libpg_query/grammar/statements/attach.y" - {} -#line 30480 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 1451: /* opt_database_alias: AS ColId */ + case 1454: #line 56 "third_party/libpg_query/grammar/statements/attach.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30486 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 1452: /* opt_database_alias: %empty */ + case 1455: #line 57 "third_party/libpg_query/grammar/statements/attach.y" - { (yyval.str) = NULL; } -#line 30492 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 1453: /* VariableResetStmt: RESET reset_rest */ + case 1456: #line 3 "third_party/libpg_query/grammar/statements/variable_reset.y" - { - (yyvsp[0].vsetstmt)->scope = VAR_SET_SCOPE_DEFAULT; - (yyval.node) = (PGNode *) (yyvsp[0].vsetstmt); - } -#line 30501 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyvsp[(2) - (2)].vsetstmt)->scope = VAR_SET_SCOPE_DEFAULT; + (yyval.node) = (PGNode *) (yyvsp[(2) - (2)].vsetstmt); + ;} break; - case 1454: /* VariableResetStmt: RESET LOCAL reset_rest */ + case 1457: #line 8 "third_party/libpg_query/grammar/statements/variable_reset.y" - { - (yyvsp[0].vsetstmt)->scope = VAR_SET_SCOPE_LOCAL; - (yyval.node) = (PGNode *) (yyvsp[0].vsetstmt); - } -#line 30510 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyvsp[(3) - (3)].vsetstmt)->scope = VAR_SET_SCOPE_LOCAL; + (yyval.node) = (PGNode *) (yyvsp[(3) - (3)].vsetstmt); + ;} break; - case 1455: /* VariableResetStmt: RESET SESSION reset_rest */ + case 1458: #line 13 "third_party/libpg_query/grammar/statements/variable_reset.y" - { - (yyvsp[0].vsetstmt)->scope = VAR_SET_SCOPE_SESSION; - (yyval.node) = (PGNode *) (yyvsp[0].vsetstmt); - } -#line 30519 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyvsp[(3) - (3)].vsetstmt)->scope = VAR_SET_SCOPE_SESSION; + (yyval.node) = (PGNode *) (yyvsp[(3) - (3)].vsetstmt); + ;} break; - case 1456: /* VariableResetStmt: RESET GLOBAL reset_rest */ + case 1459: #line 18 "third_party/libpg_query/grammar/statements/variable_reset.y" - { - (yyvsp[0].vsetstmt)->scope = VAR_SET_SCOPE_GLOBAL; - (yyval.node) = (PGNode *) (yyvsp[0].vsetstmt); - } -#line 30528 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyvsp[(3) - (3)].vsetstmt)->scope = VAR_SET_SCOPE_GLOBAL; + (yyval.node) = (PGNode *) (yyvsp[(3) - (3)].vsetstmt); + ;} break; - case 1457: /* generic_reset: var_name */ + case 1460: #line 27 "third_party/libpg_query/grammar/statements/variable_reset.y" - { + { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); n->kind = VAR_RESET; - n->name = (yyvsp[0].str); + n->name = (yyvsp[(1) - (1)].str); (yyval.vsetstmt) = n; - } -#line 30539 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1458: /* generic_reset: ALL */ + case 1461: #line 34 "third_party/libpg_query/grammar/statements/variable_reset.y" - { + { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); n->kind = VAR_RESET_ALL; (yyval.vsetstmt) = n; - } -#line 30549 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1459: /* reset_rest: generic_reset */ + case 1462: #line 43 "third_party/libpg_query/grammar/statements/variable_reset.y" - { (yyval.vsetstmt) = (yyvsp[0].vsetstmt); } -#line 30555 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.vsetstmt) = (yyvsp[(1) - (1)].vsetstmt); ;} break; - case 1460: /* reset_rest: TIME ZONE */ + case 1463: #line 45 "third_party/libpg_query/grammar/statements/variable_reset.y" - { + { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); n->kind = VAR_RESET; n->name = (char*) "timezone"; (yyval.vsetstmt) = n; - } -#line 30566 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1461: /* reset_rest: TRANSACTION ISOLATION LEVEL */ + case 1464: #line 52 "third_party/libpg_query/grammar/statements/variable_reset.y" - { + { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); n->kind = VAR_RESET; n->name = (char*) "transaction_isolation"; (yyval.vsetstmt) = n; - } -#line 30577 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1462: /* VariableShowStmt: show_or_describe SelectStmt */ + case 1465: #line 3 "third_party/libpg_query/grammar/statements/variable_show.y" - { + { PGVariableShowSelectStmt *n = makeNode(PGVariableShowSelectStmt); - n->stmt = (yyvsp[0].node); + n->stmt = (yyvsp[(2) - (2)].node); n->name = (char*) "select"; n->is_summary = 0; (yyval.node) = (PGNode *) n; - } -#line 30589 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1463: /* VariableShowStmt: SUMMARIZE SelectStmt */ + case 1466: #line 10 "third_party/libpg_query/grammar/statements/variable_show.y" - { + { PGVariableShowSelectStmt *n = makeNode(PGVariableShowSelectStmt); - n->stmt = (yyvsp[0].node); + n->stmt = (yyvsp[(2) - (2)].node); n->name = (char*) "select"; n->is_summary = 1; (yyval.node) = (PGNode *) n; - } -#line 30601 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1464: /* VariableShowStmt: SUMMARIZE table_id */ + case 1467: #line 18 "third_party/libpg_query/grammar/statements/variable_show.y" - { + { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); - n->name = (yyvsp[0].str); + n->name = (yyvsp[(2) - (2)].str); n->is_summary = 1; (yyval.node) = (PGNode *) n; - } -#line 30612 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1465: /* VariableShowStmt: show_or_describe table_id */ + case 1468: #line 25 "third_party/libpg_query/grammar/statements/variable_show.y" - { + { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); - n->name = (yyvsp[0].str); + n->name = (yyvsp[(2) - (2)].str); n->is_summary = 0; (yyval.node) = (PGNode *) n; - } -#line 30623 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1466: /* VariableShowStmt: show_or_describe TIME ZONE */ + case 1469: #line 32 "third_party/libpg_query/grammar/statements/variable_show.y" - { + { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); n->name = (char*) "timezone"; n->is_summary = 0; (yyval.node) = (PGNode *) n; - } -#line 30634 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1467: /* VariableShowStmt: show_or_describe TRANSACTION ISOLATION LEVEL */ + case 1470: #line 39 "third_party/libpg_query/grammar/statements/variable_show.y" - { + { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); n->name = (char*) "transaction_isolation"; n->is_summary = 0; (yyval.node) = (PGNode *) n; - } -#line 30645 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1468: /* VariableShowStmt: show_or_describe ALL opt_tables */ + case 1471: #line 46 "third_party/libpg_query/grammar/statements/variable_show.y" - { + { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); n->name = (char*) "__show_tables_expanded"; n->is_summary = 0; (yyval.node) = (PGNode *) n; - } -#line 30656 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1469: /* VariableShowStmt: show_or_describe */ + case 1472: #line 53 "third_party/libpg_query/grammar/statements/variable_show.y" - { + { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); n->name = (char*) "__show_tables_expanded"; n->is_summary = 0; (yyval.node) = (PGNode *) n; - } -#line 30667 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1476: /* var_name: ColId */ + case 1479: #line 67 "third_party/libpg_query/grammar/statements/variable_show.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30673 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1477: /* var_name: var_name '.' ColId */ + case 1480: #line 69 "third_party/libpg_query/grammar/statements/variable_show.y" - { (yyval.str) = psprintf("%s.%s", (yyvsp[-2].str), (yyvsp[0].str)); } -#line 30679 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = psprintf("%s.%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)); ;} break; - case 1478: /* table_id: ColId */ + case 1481: #line 72 "third_party/libpg_query/grammar/statements/variable_show.y" - { (yyval.str) = psprintf("\"%s\"", (yyvsp[0].str)); } -#line 30685 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = psprintf("\"%s\"", (yyvsp[(1) - (1)].str)); ;} break; - case 1479: /* table_id: table_id '.' ColId */ + case 1482: #line 74 "third_party/libpg_query/grammar/statements/variable_show.y" - { (yyval.str) = psprintf("%s.\"%s\"", (yyvsp[-2].str), (yyvsp[0].str)); } -#line 30691 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = psprintf("%s.\"%s\"", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)); ;} break; - case 1480: /* CallStmt: CALL_P func_application */ + case 1483: #line 7 "third_party/libpg_query/grammar/statements/call.y" - { + { PGCallStmt *n = makeNode(PGCallStmt); - n->func = (yyvsp[0].node); + n->func = (yyvsp[(2) - (2)].node); (yyval.node) = (PGNode *) n; - } -#line 30701 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1481: /* ViewStmt: CREATE_P OptTemp VIEW qualified_name opt_column_list opt_reloptions AS SelectStmt opt_check_option */ + case 1484: #line 10 "third_party/libpg_query/grammar/statements/view.y" - { + { PGViewStmt *n = makeNode(PGViewStmt); - n->view = (yyvsp[-5].range); - n->view->relpersistence = (yyvsp[-7].ival); - n->aliases = (yyvsp[-4].list); - n->query = (yyvsp[-1].node); + n->view = (yyvsp[(4) - (9)].range); + n->view->relpersistence = (yyvsp[(2) - (9)].ival); + n->aliases = (yyvsp[(5) - (9)].list); + n->query = (yyvsp[(8) - (9)].node); n->onconflict = PG_ERROR_ON_CONFLICT; - n->options = (yyvsp[-3].list); - n->withCheckOption = (yyvsp[0].viewcheckoption); + n->options = (yyvsp[(6) - (9)].list); + n->withCheckOption = (yyvsp[(9) - (9)].viewcheckoption); (yyval.node) = (PGNode *) n; - } -#line 30717 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1482: /* ViewStmt: CREATE_P OptTemp VIEW IF_P NOT EXISTS qualified_name opt_column_list opt_reloptions AS SelectStmt opt_check_option */ + case 1485: #line 23 "third_party/libpg_query/grammar/statements/view.y" - { + { PGViewStmt *n = makeNode(PGViewStmt); - n->view = (yyvsp[-5].range); - n->view->relpersistence = (yyvsp[-10].ival); - n->aliases = (yyvsp[-4].list); - n->query = (yyvsp[-1].node); + n->view = (yyvsp[(7) - (12)].range); + n->view->relpersistence = (yyvsp[(2) - (12)].ival); + n->aliases = (yyvsp[(8) - (12)].list); + n->query = (yyvsp[(11) - (12)].node); n->onconflict = PG_IGNORE_ON_CONFLICT; - n->options = (yyvsp[-3].list); - n->withCheckOption = (yyvsp[0].viewcheckoption); + n->options = (yyvsp[(9) - (12)].list); + n->withCheckOption = (yyvsp[(12) - (12)].viewcheckoption); (yyval.node) = (PGNode *) n; - } -#line 30733 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1483: /* ViewStmt: CREATE_P OR REPLACE OptTemp VIEW qualified_name opt_column_list opt_reloptions AS SelectStmt opt_check_option */ + case 1486: #line 36 "third_party/libpg_query/grammar/statements/view.y" - { + { PGViewStmt *n = makeNode(PGViewStmt); - n->view = (yyvsp[-5].range); - n->view->relpersistence = (yyvsp[-7].ival); - n->aliases = (yyvsp[-4].list); - n->query = (yyvsp[-1].node); + n->view = (yyvsp[(6) - (11)].range); + n->view->relpersistence = (yyvsp[(4) - (11)].ival); + n->aliases = (yyvsp[(7) - (11)].list); + n->query = (yyvsp[(10) - (11)].node); n->onconflict = PG_REPLACE_ON_CONFLICT; - n->options = (yyvsp[-3].list); - n->withCheckOption = (yyvsp[0].viewcheckoption); + n->options = (yyvsp[(8) - (11)].list); + n->withCheckOption = (yyvsp[(11) - (11)].viewcheckoption); (yyval.node) = (PGNode *) n; - } -#line 30749 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1484: /* ViewStmt: CREATE_P OptTemp RECURSIVE VIEW qualified_name '(' columnList ')' opt_reloptions AS SelectStmt opt_check_option */ + case 1487: #line 49 "third_party/libpg_query/grammar/statements/view.y" - { + { PGViewStmt *n = makeNode(PGViewStmt); - n->view = (yyvsp[-7].range); - n->view->relpersistence = (yyvsp[-10].ival); - n->aliases = (yyvsp[-5].list); - n->query = makeRecursiveViewSelect(n->view->relname, n->aliases, (yyvsp[-1].node)); + n->view = (yyvsp[(5) - (12)].range); + n->view->relpersistence = (yyvsp[(2) - (12)].ival); + n->aliases = (yyvsp[(7) - (12)].list); + n->query = makeRecursiveViewSelect(n->view->relname, n->aliases, (yyvsp[(11) - (12)].node)); n->onconflict = PG_ERROR_ON_CONFLICT; - n->options = (yyvsp[-3].list); - n->withCheckOption = (yyvsp[0].viewcheckoption); + n->options = (yyvsp[(9) - (12)].list); + n->withCheckOption = (yyvsp[(12) - (12)].viewcheckoption); if (n->withCheckOption != PG_NO_CHECK_OPTION) ereport(ERROR, (errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("WITH CHECK OPTION not supported on recursive views"), - parser_errposition((yylsp[0])))); + parser_errposition((yylsp[(12) - (12)])))); (yyval.node) = (PGNode *) n; - } -#line 30770 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1485: /* ViewStmt: CREATE_P OR REPLACE OptTemp RECURSIVE VIEW qualified_name '(' columnList ')' opt_reloptions AS SelectStmt opt_check_option */ + case 1488: #line 67 "third_party/libpg_query/grammar/statements/view.y" - { + { PGViewStmt *n = makeNode(PGViewStmt); - n->view = (yyvsp[-7].range); - n->view->relpersistence = (yyvsp[-10].ival); - n->aliases = (yyvsp[-5].list); - n->query = makeRecursiveViewSelect(n->view->relname, n->aliases, (yyvsp[-1].node)); + n->view = (yyvsp[(7) - (14)].range); + n->view->relpersistence = (yyvsp[(4) - (14)].ival); + n->aliases = (yyvsp[(9) - (14)].list); + n->query = makeRecursiveViewSelect(n->view->relname, n->aliases, (yyvsp[(13) - (14)].node)); n->onconflict = PG_REPLACE_ON_CONFLICT; - n->options = (yyvsp[-3].list); - n->withCheckOption = (yyvsp[0].viewcheckoption); + n->options = (yyvsp[(11) - (14)].list); + n->withCheckOption = (yyvsp[(14) - (14)].viewcheckoption); if (n->withCheckOption != PG_NO_CHECK_OPTION) ereport(ERROR, (errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("WITH CHECK OPTION not supported on recursive views"), - parser_errposition((yylsp[0])))); + parser_errposition((yylsp[(14) - (14)])))); (yyval.node) = (PGNode *) n; - } -#line 30791 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1486: /* opt_check_option: WITH CHECK_P OPTION */ + case 1489: #line 87 "third_party/libpg_query/grammar/statements/view.y" - { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; } -#line 30797 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; ;} break; - case 1487: /* opt_check_option: WITH CASCADED CHECK_P OPTION */ + case 1490: #line 88 "third_party/libpg_query/grammar/statements/view.y" - { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; } -#line 30803 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; ;} break; - case 1488: /* opt_check_option: WITH LOCAL CHECK_P OPTION */ + case 1491: #line 89 "third_party/libpg_query/grammar/statements/view.y" - { (yyval.viewcheckoption) = PG_LOCAL_CHECK_OPTION; } -#line 30809 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.viewcheckoption) = PG_LOCAL_CHECK_OPTION; ;} break; - case 1489: /* opt_check_option: %empty */ + case 1492: #line 90 "third_party/libpg_query/grammar/statements/view.y" - { (yyval.viewcheckoption) = PG_NO_CHECK_OPTION; } -#line 30815 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.viewcheckoption) = PG_NO_CHECK_OPTION; ;} break; - case 1490: /* CreateAsStmt: CREATE_P OptTemp TABLE create_as_target AS SelectStmt opt_with_data */ + case 1493: #line 12 "third_party/libpg_query/grammar/statements/create_as.y" - { + { PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt); - ctas->query = (yyvsp[-1].node); - ctas->into = (yyvsp[-3].into); + ctas->query = (yyvsp[(6) - (7)].node); + ctas->into = (yyvsp[(4) - (7)].into); ctas->relkind = PG_OBJECT_TABLE; ctas->is_select_into = false; ctas->onconflict = PG_ERROR_ON_CONFLICT; /* cram additional flags into the PGIntoClause */ - (yyvsp[-3].into)->rel->relpersistence = (yyvsp[-5].ival); - (yyvsp[-3].into)->skipData = !((yyvsp[0].boolean)); + (yyvsp[(4) - (7)].into)->rel->relpersistence = (yyvsp[(2) - (7)].ival); + (yyvsp[(4) - (7)].into)->skipData = !((yyvsp[(7) - (7)].boolean)); (yyval.node) = (PGNode *) ctas; - } -#line 30832 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1491: /* CreateAsStmt: CREATE_P OptTemp TABLE IF_P NOT EXISTS create_as_target AS SelectStmt opt_with_data */ + case 1494: #line 25 "third_party/libpg_query/grammar/statements/create_as.y" - { + { PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt); - ctas->query = (yyvsp[-1].node); - ctas->into = (yyvsp[-3].into); + ctas->query = (yyvsp[(9) - (10)].node); + ctas->into = (yyvsp[(7) - (10)].into); ctas->relkind = PG_OBJECT_TABLE; ctas->is_select_into = false; ctas->onconflict = PG_IGNORE_ON_CONFLICT; /* cram additional flags into the PGIntoClause */ - (yyvsp[-3].into)->rel->relpersistence = (yyvsp[-8].ival); - (yyvsp[-3].into)->skipData = !((yyvsp[0].boolean)); + (yyvsp[(7) - (10)].into)->rel->relpersistence = (yyvsp[(2) - (10)].ival); + (yyvsp[(7) - (10)].into)->skipData = !((yyvsp[(10) - (10)].boolean)); (yyval.node) = (PGNode *) ctas; - } -#line 30849 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1492: /* CreateAsStmt: CREATE_P OR REPLACE OptTemp TABLE create_as_target AS SelectStmt opt_with_data */ + case 1495: #line 38 "third_party/libpg_query/grammar/statements/create_as.y" - { + { PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt); - ctas->query = (yyvsp[-1].node); - ctas->into = (yyvsp[-3].into); + ctas->query = (yyvsp[(8) - (9)].node); + ctas->into = (yyvsp[(6) - (9)].into); ctas->relkind = PG_OBJECT_TABLE; ctas->is_select_into = false; ctas->onconflict = PG_REPLACE_ON_CONFLICT; /* cram additional flags into the PGIntoClause */ - (yyvsp[-3].into)->rel->relpersistence = (yyvsp[-5].ival); - (yyvsp[-3].into)->skipData = !((yyvsp[0].boolean)); + (yyvsp[(6) - (9)].into)->rel->relpersistence = (yyvsp[(4) - (9)].ival); + (yyvsp[(6) - (9)].into)->skipData = !((yyvsp[(9) - (9)].boolean)); (yyval.node) = (PGNode *) ctas; - } -#line 30866 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1493: /* opt_with_data: WITH DATA_P */ + case 1496: #line 54 "third_party/libpg_query/grammar/statements/create_as.y" - { (yyval.boolean) = true; } -#line 30872 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1494: /* opt_with_data: WITH NO DATA_P */ + case 1497: #line 55 "third_party/libpg_query/grammar/statements/create_as.y" - { (yyval.boolean) = false; } -#line 30878 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1495: /* opt_with_data: %empty */ + case 1498: #line 56 "third_party/libpg_query/grammar/statements/create_as.y" - { (yyval.boolean) = true; } -#line 30884 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1496: /* create_as_target: qualified_name opt_column_list OptWith OnCommitOption */ + case 1499: #line 62 "third_party/libpg_query/grammar/statements/create_as.y" - { + { (yyval.into) = makeNode(PGIntoClause); - (yyval.into)->rel = (yyvsp[-3].range); - (yyval.into)->colNames = (yyvsp[-2].list); - (yyval.into)->options = (yyvsp[-1].list); - (yyval.into)->onCommit = (yyvsp[0].oncommit); + (yyval.into)->rel = (yyvsp[(1) - (4)].range); + (yyval.into)->colNames = (yyvsp[(2) - (4)].list); + (yyval.into)->options = (yyvsp[(3) - (4)].list); + (yyval.into)->onCommit = (yyvsp[(4) - (4)].oncommit); (yyval.into)->viewQuery = NULL; (yyval.into)->skipData = false; /* might get changed later */ - } -#line 30898 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; -#line 30902 "third_party/libpg_query/grammar/grammar_out.cpp" - +/* Line 1267 of yacc.c. */ +#line 30697 "third_party/libpg_query/grammar/grammar_out.cpp" default: break; } - /* User semantic actions sometimes alter yychar, and that requires - that yytoken be updated with the new translation. We take the - approach of translating immediately before every use of yytoken. - One alternative is translating here after every semantic action, - but that translation would be missed if the semantic action invokes - YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or - if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an - incorrect destructor might then be invoked immediately. In the - case of YYERROR or YYBACKUP, subsequent parser actions might lead - to an incorrect destructor call or verbose syntax error message - before the lookahead is translated. */ - YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); YYPOPSTACK (yylen); yylen = 0; + YY_STACK_PRINT (yyss, yyssp); *++yyvsp = yyval; *++yylsp = yyloc; - /* Now 'shift' the result of the reduction. Determine what state + /* Now `shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ - { - const int yylhs = yyr1[yyn] - YYNTOKENS; - const int yyi = yypgoto[yylhs] + *yyssp; - yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp - ? yytable[yyi] - : yydefgoto[yylhs]); - } + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; goto yynewstate; -/*--------------------------------------. -| yyerrlab -- here on detecting error. | -`--------------------------------------*/ +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ yyerrlab: - /* Make sure we have latest lookahead translation. See comments at - user semantic actions for why this is necessary. */ - yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); /* If not already recovering from an error, report this error. */ if (!yyerrstatus) { ++yynerrs; +#if ! YYERROR_VERBOSE yyerror (&yylloc, yyscanner, YY_("syntax error")); +#else + { + YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); + if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) + { + YYSIZE_T yyalloc = 2 * yysize; + if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) + yyalloc = YYSTACK_ALLOC_MAXIMUM; + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yyalloc); + if (yymsg) + yymsg_alloc = yyalloc; + else + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + } + } + + if (0 < yysize && yysize <= yymsg_alloc) + { + (void) yysyntax_error (yymsg, yystate, yychar); + yyerror (&yylloc, yyscanner, yymsg); + } + else + { + yyerror (&yylloc, yyscanner, YY_("syntax error")); + if (yysize != 0) + goto yyexhaustedlab; + } + } +#endif } - yyerror_range[1] = yylloc; + yyerror_range[0] = yylloc; + if (yyerrstatus == 3) { - /* If just tried and failed to reuse lookahead token after an - error, discard it. */ + /* If just tried and failed to reuse look-ahead token after an + error, discard it. */ if (yychar <= YYEOF) - { - /* Return failure if at end of input. */ - if (yychar == YYEOF) - YYABORT; - } + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } else - { - yydestruct ("Error: discarding", - yytoken, &yylval, &yylloc, yyscanner); - yychar = YYEMPTY; - } + { + yydestruct ("Error: discarding", + yytoken, &yylval, &yylloc, yyscanner); + yychar = YYEMPTY; + } } - /* Else will try to reuse lookahead token after shifting the error + /* Else will try to reuse look-ahead token after shifting the error token. */ goto yyerrlab1; @@ -417494,13 +420728,15 @@ YYLTYPE yylloc = yyloc_default; | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ yyerrorlab: - /* Pacify compilers when the user code never invokes YYERROR and the - label yyerrorlab therefore never appears in user code. */ - if (0) - YYERROR; - ++yynerrs; - /* Do not reclaim the symbols of the rule whose action triggered + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + yyerror_range[0] = yylsp[1-yylen]; + /* Do not reclaim the symbols of the rule which action triggered this YYERROR. */ YYPOPSTACK (yylen); yylen = 0; @@ -417513,45 +420749,47 @@ YYLTYPE yylloc = yyloc_default; | yyerrlab1 -- common code for both syntax error and YYERROR. | `-------------------------------------------------------------*/ yyerrlab1: - yyerrstatus = 3; /* Each real token shifted decrements this. */ + yyerrstatus = 3; /* Each real token shifted decrements this. */ - /* Pop stack until we find a state that shifts the error token. */ for (;;) { yyn = yypact[yystate]; - if (!yypact_value_is_default (yyn)) - { - yyn += YYSYMBOL_YYerror; - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) - { - yyn = yytable[yyn]; - if (0 < yyn) - break; - } - } + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } /* Pop the current state because it cannot handle the error token. */ if (yyssp == yyss) - YYABORT; + YYABORT; - yyerror_range[1] = *yylsp; + yyerror_range[0] = *yylsp; yydestruct ("Error: popping", - YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, yyscanner); + yystos[yystate], yyvsp, yylsp, yyscanner); YYPOPSTACK (1); yystate = *yyssp; YY_STACK_PRINT (yyss, yyssp); } - YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + if (yyn == YYFINAL) + YYACCEPT; + *++yyvsp = yylval; - YY_IGNORE_MAYBE_UNINITIALIZED_END - yyerror_range[2] = yylloc; - ++yylsp; - YYLLOC_DEFAULT (*yylsp, yyerror_range, 2); + yyerror_range[1] = yylloc; + /* Using YYLLOC is tempting, but would change the location of + the look-ahead. YYLOC is available though. */ + YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); + *++yylsp = yyloc; /* Shift the error token. */ - YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); yystate = yyn; goto yynewstate; @@ -417562,56 +420800,52 @@ YYLTYPE yylloc = yyloc_default; `-------------------------------------*/ yyacceptlab: yyresult = 0; - goto yyreturnlab; - + goto yyreturn; /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: yyresult = 1; - goto yyreturnlab; + goto yyreturn; - -/*-----------------------------------------------------------. -| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | -`-----------------------------------------------------------*/ +#ifndef yyoverflow +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ yyexhaustedlab: yyerror (&yylloc, yyscanner, YY_("memory exhausted")); yyresult = 2; - goto yyreturnlab; - + /* Fall through. */ +#endif -/*----------------------------------------------------------. -| yyreturnlab -- parsing is finished, clean up and return. | -`----------------------------------------------------------*/ -yyreturnlab: - if (yychar != YYEMPTY) - { - /* Make sure we have latest lookahead translation. See comments at - user semantic actions for why this is necessary. */ - yytoken = YYTRANSLATE (yychar); - yydestruct ("Cleanup: discarding lookahead", - yytoken, &yylval, &yylloc, yyscanner); - } - /* Do not reclaim the symbols of the rule whose action triggered +yyreturn: + if (yychar != YYEOF && yychar != YYEMPTY) + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval, &yylloc, yyscanner); + /* Do not reclaim the symbols of the rule which action triggered this YYABORT or YYACCEPT. */ YYPOPSTACK (yylen); YY_STACK_PRINT (yyss, yyssp); while (yyssp != yyss) { yydestruct ("Cleanup: popping", - YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, yyscanner); + yystos[*yyssp], yyvsp, yylsp, yyscanner); YYPOPSTACK (1); } #ifndef yyoverflow if (yyss != yyssa) YYSTACK_FREE (yyss); #endif - - return yyresult; +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + /* Make sure YYID is used. */ + return YYID (yyresult); } + #line 83 "third_party/libpg_query/grammar/statements/create_as.y" @@ -418371,6 +421605,7 @@ parser_init(base_yy_extra_type *yyext) } // namespace duckdb_libpgquery + // LICENSE_CHANGE_END @@ -423983,9 +427218,6 @@ const PGScanKeyword *ScanKeywordLookup(const char *text, const PGScanKeyword *ke #define MBEDTLS_ARIA_C #define MBEDTLS_GCM_C #define MBEDTLS_ENTROPY_C -#if defined(_WIN32) -#define MBEDTLS_NO_PLATFORM_ENTROPY -#endif // LICENSE_CHANGE_END @@ -450117,12 +453349,12 @@ int mbedtls_entropy_self_test( int verbose ) #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32) -#if !defined(_WIN32_WINNT) -#define _WIN32_WINNT 0x0400 -#endif #include -#include +#include +#include +#if defined(__MINGW32__) +// MINGW int mbedtls_platform_entropy_poll( void *data, unsigned char *output, size_t len, size_t *olen ) { @@ -450147,6 +453379,34 @@ int mbedtls_platform_entropy_poll( void *data, unsigned char *output, size_t len return( 0 ); } +#else +int mbedtls_platform_entropy_poll(void *data, unsigned char *output, size_t len, + size_t *olen) +{ + ((void) data); + *olen = 0; + + /* + * BCryptGenRandom takes ULONG for size, which is smaller than size_t on + * 64-bit Windows platforms. Extract entropy in chunks of len (dependent + * on ULONG_MAX) size. + */ + while (len != 0) { + unsigned long ulong_bytes = + (len > ULONG_MAX) ? ULONG_MAX : (unsigned long) len; + + if (!BCRYPT_SUCCESS(BCryptGenRandom(NULL, output, ulong_bytes, + BCRYPT_USE_SYSTEM_PREFERRED_RNG))) { + return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED; + } + + *olen += ulong_bytes; + len -= ulong_bytes; + } + + return 0; +} +#endif #else /* _WIN32 && !EFIX64 && !EFI32 */ /* diff --git a/c_src/duckdb/duckdb.hpp b/c_src/duckdb/duckdb.hpp index 6ecaeb7..55b9d04 100644 --- a/c_src/duckdb/duckdb.hpp +++ b/c_src/duckdb/duckdb.hpp @@ -10,8 +10,11 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI #pragma once #define DUCKDB_AMALGAMATION 1 -#define DUCKDB_SOURCE_ID "20b1486d11" -#define DUCKDB_VERSION "v0.10.0" +#define DUCKDB_SOURCE_ID "4a89d97db8" +#define DUCKDB_VERSION "v0.10.1" +#define DUCKDB_MAJOR_VERSION 0 +#define DUCKDB_MINOR_VERSION 10 +#define DUCKDB_PATCH_VERSION "1" //===----------------------------------------------------------------------===// // DuckDB // @@ -753,6 +756,8 @@ class TypeMismatchException : public Exception { public: DUCKDB_API TypeMismatchException(const PhysicalType type_1, const PhysicalType type_2, const string &msg); DUCKDB_API TypeMismatchException(const LogicalType &type_1, const LogicalType &type_2, const string &msg); + DUCKDB_API TypeMismatchException(optional_idx error_location, const LogicalType &type_1, const LogicalType &type_2, + const string &msg); DUCKDB_API TypeMismatchException(const string &msg); //! Needed to be able to recreate the exception after it's been serialized }; @@ -1273,6 +1278,13 @@ bool RefersToSameObject(const T &A, const T &B) { return &A == &B; } +template +void DynamicCastCheck(SRC *source) { +#ifndef __APPLE__ + D_ASSERT(dynamic_cast(source)); +#endif +} + } // namespace duckdb //===----------------------------------------------------------------------===// @@ -2054,7 +2066,7 @@ struct LogicalType { static constexpr const LogicalTypeId ROW_TYPE = LogicalTypeId::BIGINT; // explicitly allowing these functions to be capitalized to be in-line with the remaining functions - DUCKDB_API static LogicalType DECIMAL(int width, int scale); // NOLINT + DUCKDB_API static LogicalType DECIMAL(uint8_t width, uint8_t scale); // NOLINT DUCKDB_API static LogicalType VARCHAR_COLLATION(string collation); // NOLINT DUCKDB_API static LogicalType LIST(const LogicalType &child); // NOLINT DUCKDB_API static LogicalType STRUCT(child_list_t children); // NOLINT @@ -2362,10 +2374,10 @@ struct NumericLimits { static constexpr T Maximum() { return std::numeric_limits::max(); } - DUCKDB_API static constexpr bool IsSigned() { + static constexpr bool IsSigned() { return std::is_signed::value; } - DUCKDB_API static constexpr idx_t Digits(); + static constexpr idx_t Digits(); }; template <> @@ -2864,14 +2876,19 @@ class Timestamp { DUCKDB_API static timestamp_t GetCurrentTimestamp(); //! Convert the epoch (in sec) to a timestamp - DUCKDB_API static timestamp_t FromEpochSeconds(int64_t ms); + DUCKDB_API static timestamp_t FromEpochSecondsPossiblyInfinite(int64_t s); + DUCKDB_API static timestamp_t FromEpochSeconds(int64_t s); //! Convert the epoch (in ms) to a timestamp + DUCKDB_API static timestamp_t FromEpochMsPossiblyInfinite(int64_t ms); DUCKDB_API static timestamp_t FromEpochMs(int64_t ms); //! Convert the epoch (in microseconds) to a timestamp DUCKDB_API static timestamp_t FromEpochMicroSeconds(int64_t micros); //! Convert the epoch (in nanoseconds) to a timestamp - DUCKDB_API static timestamp_t FromEpochNanoSeconds(int64_t micros); + DUCKDB_API static timestamp_t FromEpochNanoSecondsPossiblyInfinite(int64_t nanos); + DUCKDB_API static timestamp_t FromEpochNanoSeconds(int64_t nanos); + //! Try convert a timestamp to epoch (in nanoseconds) + DUCKDB_API static bool TryGetEpochNanoSeconds(timestamp_t timestamp, int64_t &result); //! Convert the epoch (in seconds) to a timestamp DUCKDB_API static int64_t GetEpochSeconds(timestamp_t timestamp); //! Convert the epoch (in ms) to a timestamp @@ -2960,6 +2977,132 @@ struct hash { +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/common/numeric_utils.hpp +// +// +//===----------------------------------------------------------------------===// + + + +#include + + + + +namespace duckdb { + +template +struct MakeSigned { + using type = typename std::make_signed::type; +}; + +template <> +struct MakeSigned { + using type = hugeint_t; +}; + +template <> +struct MakeSigned { + using type = hugeint_t; +}; + +template +struct MakeUnsigned { + using type = typename std::make_unsigned::type; +}; + +template <> +struct MakeUnsigned { + using type = uhugeint_t; +}; + +template <> +struct MakeUnsigned { + using type = uhugeint_t; +}; + +template +struct IsIntegral { + static constexpr bool value = std::is_integral::value; +}; + +template <> +struct IsIntegral { + static constexpr bool value = true; +}; + +template <> +struct IsIntegral { + static constexpr bool value = true; +}; + +template +static void ThrowNumericCastError(FROM in, TO minval, TO maxval) { + throw InternalException("Information loss on integer cast: value %d outside of target range [%d, %d]", in, minval, + maxval); +} + +template +TO NumericCast(FROM val) { + // some dance around signed-unsigned integer comparison below + auto minval = NumericLimits::Minimum(); + auto maxval = NumericLimits::Maximum(); + auto unsigned_in = static_cast::type>(val); + auto unsigned_min = static_cast::type>(minval); + auto unsigned_max = static_cast::type>(maxval); + auto signed_in = static_cast::type>(val); + auto signed_min = static_cast::type>(minval); + auto signed_max = static_cast::type>(maxval); + + if (std::is_unsigned() && std::is_unsigned() && + (unsigned_in < unsigned_min || unsigned_in > unsigned_max)) { + ThrowNumericCastError(val, minval, maxval); + } + + if (std::is_signed() && std::is_signed() && (signed_in < signed_min || signed_in > signed_max)) { + ThrowNumericCastError(val, minval, maxval); + } + + if (std::is_signed() != std::is_signed() && (signed_in < signed_min || unsigned_in > unsigned_max)) { + ThrowNumericCastError(val, minval, maxval); + } + + return static_cast(val); +} + +template +TO NumericCast(double val) { + return static_cast(val); +} + +template +TO NumericCast(float val) { + return static_cast(val); +} + +template +TO UnsafeNumericCast(FROM in) { +#ifdef DEBUG + return NumericCast(in); +#endif + return static_cast(in); +} + +template +TO UnsafeNumericCast(double val) { + return NumericCast(val); +} + +template +TO UnsafeNumericCast(float val) { + return NumericCast(val); +} + +} // namespace duckdb + #include @@ -3007,10 +3150,14 @@ struct string_t { value.pointer.ptr = (char *)data; // NOLINT } } - string_t(const char *data) : string_t(data, strlen(data)) { // NOLINT: Allow implicit conversion from `const char*` + + string_t(const char *data) + : string_t(data, + UnsafeNumericCast(strlen(data))) { // NOLINT: Allow implicit conversion from `const char*` } string_t(const string &value) - : string_t(value.c_str(), value.size()) { // NOLINT: Allow implicit conversion from `const char*` + : string_t(value.c_str(), + UnsafeNumericCast(value.size())) { // NOLINT: Allow implicit conversion from `const char*` } bool IsInlined() const { @@ -3079,6 +3226,8 @@ struct string_t { } void Verify() const; + void VerifyUTF8() const; + void VerifyCharacters() const; void VerifyNull() const; struct StringComparisonOperators { @@ -3114,8 +3263,8 @@ struct string_t { } // compare up to shared length. if still the same, compare lengths static bool GreaterThan(const string_t &left, const string_t &right) { - const uint32_t left_length = left.GetSize(); - const uint32_t right_length = right.GetSize(); + const uint32_t left_length = UnsafeNumericCast(left.GetSize()); + const uint32_t right_length = UnsafeNumericCast(right.GetSize()); const uint32_t min_length = std::min(left_length, right_length); #ifndef DUCKDB_DEBUG_NO_INLINE @@ -3742,6 +3891,8 @@ class Value { DUCKDB_API explicit Value(LogicalType type = LogicalType::SQLNULL); //! Create an INTEGER value DUCKDB_API Value(int32_t val); // NOLINT: Allow implicit conversion from `int32_t` + //! Create a BOOLEAN value + explicit DUCKDB_API Value(bool val); //! Create a BIGINT value DUCKDB_API Value(int64_t val); // NOLINT: Allow implicit conversion from `int64_t` //! Create a FLOAT value @@ -3892,6 +4043,9 @@ class Value { DUCKDB_API static Value BIT(const_data_ptr_t data, idx_t len); DUCKDB_API static Value BIT(const string &data); + //! Creates an aggregate state + DUCKDB_API static Value AGGREGATE_STATE(const LogicalType &type, const_data_ptr_t data, idx_t len); + template T GetValue() const; template @@ -4259,6 +4413,8 @@ DUCKDB_API date_t Value::GetValueUnsafe() const; template <> DUCKDB_API dtime_t Value::GetValueUnsafe() const; template <> +DUCKDB_API dtime_tz_t Value::GetValueUnsafe() const; +template <> DUCKDB_API timestamp_t Value::GetValueUnsafe() const; template <> DUCKDB_API interval_t Value::GetValueUnsafe() const; @@ -4359,7 +4515,7 @@ class CatalogEntry { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -4521,6 +4677,28 @@ enum class OnEntryNotFound : uint8_t { THROW_EXCEPTION = 0, RETURN_NULL = 1 }; } // namespace duckdb +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/common/enums/catalog_lookup_behavior.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + +namespace duckdb { + +//! Enum used for indicating lookup behavior of specific catalog types +// STANDARD means the catalog lookups are performed in a regular manner (i.e. according to the users' search path) +// LOWER_PRIORITY means the catalog lookups are de-prioritized and we do lookups in other catalogs first +// NEVER_LOOKUP means we never do lookups for this specific type in this catalog +enum class CatalogLookupBehavior : uint8_t { STANDARD = 0, LOWER_PRIORITY = 1, NEVER_LOOKUP = 2 }; + +} // namespace duckdb + #include namespace duckdb { @@ -4695,6 +4873,10 @@ class Catalog { DUCKDB_API optional_ptr GetSchema(ClientContext &context, const string &name, OnEntryNotFound if_not_found, QueryErrorContext error_context = QueryErrorContext()); + //! Overloadable method for giving warnings on ambiguous naming id.tab due to a database and schema with name id + DUCKDB_API virtual bool CheckAmbiguousCatalogOrSchema(ClientContext &context, const string &name) { + return !!GetSchema(context, name, OnEntryNotFound::RETURN_NULL); + } DUCKDB_API SchemaCatalogEntry &GetSchema(CatalogTransaction transaction, const string &name, QueryErrorContext error_context = QueryErrorContext()); DUCKDB_API virtual optional_ptr @@ -4777,6 +4959,11 @@ class Catalog { virtual bool InMemory() = 0; virtual string GetDBPath() = 0; + //! Whether or not this catalog should search a specific type with the standard priority + DUCKDB_API virtual CatalogLookupBehavior CatalogTypeLookupRule(CatalogType type) const { + return CatalogLookupBehavior::STANDARD; + } + public: template static optional_ptr GetEntry(ClientContext &context, const string &catalog_name, const string &schema_name, @@ -4852,7 +5039,7 @@ class Catalog { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } @@ -5107,7 +5294,7 @@ struct FileHandle { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -5137,6 +5324,8 @@ class FileFlags { static constexpr uint8_t FILE_FLAGS_FILE_CREATE_NEW = 1 << 4; //! Open file in append mode static constexpr uint8_t FILE_FLAGS_APPEND = 1 << 5; + //! Open file with restrictive permissions (600 on linux/mac) can only be used when creating, throws if file exists + static constexpr uint8_t FILE_FLAGS_PRIVATE = 1 << 6; }; class FileSystem { @@ -5413,6 +5602,7 @@ string VectorTypeToString(VectorType type); + //===----------------------------------------------------------------------===// // DuckDB // @@ -5513,7 +5703,7 @@ struct SelectionVector { } inline void set_index(idx_t idx, idx_t loc) { - sel_vector[idx] = loc; + sel_vector[idx] = UnsafeNumericCast(loc); } inline void swap(idx_t i, idx_t j) { sel_t tmp = sel_vector[i]; @@ -6052,6 +6242,8 @@ struct ValidityMask : public TemplatedValidityMask { + + namespace duckdb { class Allocator; class AttachedDatabase; @@ -6070,7 +6262,7 @@ struct PrivateAllocatorData { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -6136,16 +6328,10 @@ class Allocator { AllocatedData Allocate(idx_t size) { return AllocatedData(*this, AllocateData(size), size); } - static data_ptr_t DefaultAllocate(PrivateAllocatorData *private_data, idx_t size) { - return data_ptr_cast(malloc(size)); - } - static void DefaultFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size) { - free(pointer); - } + static data_ptr_t DefaultAllocate(PrivateAllocatorData *private_data, idx_t size); + static void DefaultFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size); static data_ptr_t DefaultReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size, - idx_t size) { - return data_ptr_cast(realloc(pointer, size)); - } + idx_t size); static Allocator &Get(ClientContext &context); static Allocator &Get(DatabaseInstance &db); static Allocator &Get(AttachedDatabase &db); @@ -6158,6 +6344,7 @@ class Allocator { DUCKDB_API static shared_ptr &DefaultAllocatorReference(); static void ThreadFlush(idx_t threshold); + static void FlushAll(); private: allocate_function_ptr_t allocate_function; @@ -6239,7 +6426,10 @@ class ArenaAllocator { DUCKDB_API ArenaChunk *GetTail(); DUCKDB_API bool IsEmpty() const; + //! Get the total *used* size (not cached) DUCKDB_API idx_t SizeInBytes() const; + //! Get the currently allocated size in bytes (cached, read from "allocated_size") + DUCKDB_API idx_t AllocationSize() const; //! Returns an "Allocator" wrapper for this arena allocator Allocator &GetAllocator() { @@ -6254,6 +6444,8 @@ class ArenaAllocator { ArenaChunk *tail; //! An allocator wrapper using this arena allocator Allocator arena_allocator; + //! The total allocated size + idx_t allocated_size = 0; }; } // namespace duckdb @@ -6287,6 +6479,8 @@ class StringHeap { //! Size of strings DUCKDB_API idx_t SizeInBytes() const; + //! Total allocation size (cached) + DUCKDB_API idx_t AllocationSize() const; private: ArenaAllocator allocator; @@ -6589,7 +6783,7 @@ class VectorBuffer { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -6772,6 +6966,14 @@ class ManagedVectorBuffer : public VectorBuffer { namespace duckdb { struct UnifiedVectorFormat { + DUCKDB_API UnifiedVectorFormat(); + // disable copy constructors + UnifiedVectorFormat(const UnifiedVectorFormat &other) = delete; + UnifiedVectorFormat &operator=(const UnifiedVectorFormat &) = delete; + //! enable move constructors + DUCKDB_API UnifiedVectorFormat(UnifiedVectorFormat &&other) noexcept; + DUCKDB_API UnifiedVectorFormat &operator=(UnifiedVectorFormat &&) noexcept; + const SelectionVector *sel; data_ptr_t data; ValidityMask validity; @@ -6957,6 +7159,11 @@ class Vector { // Setters DUCKDB_API void SetVectorType(VectorType vector_type); + // Transform vector to an equivalent dictionary vector + static void DebugTransformToDictionary(Vector &vector, idx_t count); + // Transform vector to an equivalent nested vector + static void DebugShuffleNestedVector(Vector &vector, idx_t count); + private: //! Returns the [index] element of the Vector as a Value. static Value GetValue(const Vector &v, idx_t index); @@ -7047,6 +7254,16 @@ struct DictionaryVector { }; struct FlatVector { + static void VerifyFlatVector(const Vector &vector) { +#ifdef DUCKDB_DEBUG_NO_SAFETY + D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR); +#else + if (vector.GetVectorType() != VectorType::FLAT_VECTOR) { + throw InternalException("Operation requires a flat vector but a non-flat vector was encountered"); + } +#endif + } + static inline data_ptr_t GetData(Vector &vector) { return ConstantVector::GetData(vector); } @@ -7068,15 +7285,15 @@ struct FlatVector { return FlatVector::GetData(vector)[idx]; } static inline const ValidityMask &Validity(const Vector &vector) { - D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR); + VerifyFlatVector(vector); return vector.validity; } static inline ValidityMask &Validity(Vector &vector) { - D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR); + VerifyFlatVector(vector); return vector.validity; } - static inline void SetValidity(Vector &vector, ValidityMask &new_validity) { - D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR); + static inline void SetValidity(Vector &vector, const ValidityMask &new_validity) { + VerifyFlatVector(vector); vector.validity.Initialize(new_validity); } DUCKDB_API static void SetNull(Vector &vector, idx_t idx, bool is_null); @@ -7189,7 +7406,15 @@ struct FSSTVector { DUCKDB_API static idx_t GetCount(Vector &vector); }; -enum class MapInvalidReason : uint8_t { VALID, NULL_KEY_LIST, NULL_KEY, DUPLICATE_KEY }; +enum class MapInvalidReason : uint8_t { + VALID, + NULL_KEY_LIST, + NULL_KEY, + DUPLICATE_KEY, + NULL_VALUE_LIST, + NOT_ALIGNED, + INVALID_PARAMS +}; struct MapVector { DUCKDB_API static const Vector &GetKeys(const Vector &vector); @@ -7198,6 +7423,7 @@ struct MapVector { DUCKDB_API static Vector &GetValues(Vector &vector); DUCKDB_API static MapInvalidReason CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel = *FlatVector::IncrementalSelectionVector()); + DUCKDB_API static void EvalMapInvalidReason(MapInvalidReason reason); DUCKDB_API static void MapConversionVerify(Vector &vector, idx_t count); }; @@ -7246,8 +7472,9 @@ struct UnionVector { DUCKDB_API static const Vector &GetTags(const Vector &v); DUCKDB_API static Vector &GetTags(Vector &v); - //! Get the tag at the specific index of the union vector - DUCKDB_API static union_tag_t GetTag(const Vector &vector, idx_t index); + //! Try to get the tag at the specific flat index of the union vector. Returns false if the tag is NULL. + //! This will handle and map the index properly for constant and dictionary vectors internally. + DUCKDB_API static bool TryGetTag(const Vector &vector, idx_t index, union_tag_t &tag); //! Get the member vector of a union vector by index DUCKDB_API static const Vector &GetMember(const Vector &vector, idx_t member_index); @@ -7937,11 +8164,12 @@ struct VectorOperations { //! NULLs. If any elements cannot be converted, returns false and fills in the error_message. If no error message is //! provided, an exception is thrown instead. DUCKDB_API static bool TryCast(CastFunctionSet &set, GetCastFunctionInput &input, Vector &source, Vector &result, - idx_t count, string *error_message, bool strict = false); + idx_t count, string *error_message, bool strict = false, + const bool nullify_parent = false); DUCKDB_API static bool DefaultTryCast(Vector &source, Vector &result, idx_t count, string *error_message, bool strict = false); DUCKDB_API static bool TryCast(ClientContext &context, Vector &source, Vector &result, idx_t count, - string *error_message, bool strict = false); + string *error_message, bool strict = false, const bool nullify_parent = false); //! Cast the data from the source type to the target type. Throws an exception if the cast fails. DUCKDB_API static void Cast(ClientContext &context, Vector &source, Vector &result, idx_t count, bool strict = false); @@ -9498,6 +9726,10 @@ class ParserException : public Exception { template explicit ParserException(const string &msg, Args... params) : ParserException(ConstructMessage(msg, params...)) { } + template + explicit ParserException(optional_idx error_location, const string &msg, Args... params) + : ParserException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(error_location)) { + } static ParserException SyntaxError(const string &query, const string &error_message, optional_idx error_location); }; @@ -9896,7 +10128,7 @@ struct FunctionData { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -10047,7 +10279,7 @@ struct ExpressionState { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -11050,7 +11282,7 @@ struct FunctionLocalState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -12190,6 +12422,7 @@ class Expression : public BaseExpression { expression_class = other.expression_class; alias = other.alias; return_type = other.return_type; + query_location = other.query_location; } }; @@ -12248,6 +12481,63 @@ struct BoundOrderByNode { static BoundOrderByNode Deserialize(Deserializer &deserializer); }; +enum class LimitNodeType : uint8_t { + UNSET = 0, + CONSTANT_VALUE = 1, + CONSTANT_PERCENTAGE = 2, + EXPRESSION_VALUE = 3, + EXPRESSION_PERCENTAGE = 4 +}; + +struct BoundLimitNode { +public: + BoundLimitNode(); + BoundLimitNode(LimitNodeType type, idx_t constant_integer, double constant_percentage, + unique_ptr expression); + +public: + static BoundLimitNode ConstantValue(int64_t value); + static BoundLimitNode ConstantPercentage(double percentage); + static BoundLimitNode ExpressionValue(unique_ptr expression); + static BoundLimitNode ExpressionPercentage(unique_ptr expression); + + LimitNodeType Type() const { + return type; + } + + //! Returns the constant value, only valid if Type() == CONSTANT_VALUE + idx_t GetConstantValue() const; + //! Returns the constant percentage, only valid if Type() == CONSTANT_PERCENTAGE + double GetConstantPercentage() const; + //! Returns the constant percentage, only valid if Type() == EXPRESSION_VALUE + const Expression &GetValueExpression() const; + //! Returns the constant percentage, only valid if Type() == EXPRESSION_PERCENTAGE + const Expression &GetPercentageExpression() const; + + //! Returns a pointer to the expression - should only be used for limit-agnostic optimizations. + //! Prefer using the methods above in other scenarios. + unique_ptr &GetExpression() { + return expression; + } + + void Serialize(Serializer &serializer) const; + static BoundLimitNode Deserialize(Deserializer &deserializer); + +private: + LimitNodeType type = LimitNodeType::UNSET; + //! Integer value, if value is a constant non-percentage + idx_t constant_integer = 0; + //! Percentage value, if value is a constant percentage + double constant_percentage = -1; + //! Expression in case node is not constant + unique_ptr expression; + +private: + explicit BoundLimitNode(int64_t constant_value); + explicit BoundLimitNode(double percentage_value); + explicit BoundLimitNode(unique_ptr expression, bool is_percentage); +}; + class BoundLimitModifier : public BoundResultModifier { public: static constexpr const ResultModifierType TYPE = ResultModifierType::LIMIT_MODIFIER; @@ -12256,13 +12546,9 @@ class BoundLimitModifier : public BoundResultModifier { BoundLimitModifier(); //! LIMIT - int64_t limit_val = NumericLimits::Maximum(); + BoundLimitNode limit_val; //! OFFSET - int64_t offset_val = 0; - //! Expression in case limit is not constant - unique_ptr limit; - //! Expression in case limit is not constant - unique_ptr offset; + BoundLimitNode offset_val; }; class BoundOrderModifier : public BoundResultModifier { @@ -12302,23 +12588,6 @@ class BoundDistinctModifier : public BoundResultModifier { vector> target_distincts; }; -class BoundLimitPercentModifier : public BoundResultModifier { -public: - static constexpr const ResultModifierType TYPE = ResultModifierType::LIMIT_PERCENT_MODIFIER; - -public: - BoundLimitPercentModifier(); - - //! LIMIT % - double limit_percent = 100.0; - //! OFFSET - int64_t offset_val = 0; - //! Expression in case limit is not constant - unique_ptr limit; - //! Expression in case limit is not constant - unique_ptr offset; -}; - } // namespace duckdb @@ -13234,6 +13503,8 @@ class ColumnDataCollection { //! The size (in bytes) of this ColumnDataCollection idx_t SizeInBytes() const; + //! The allocation size (in bytes) of this ColumnDataCollection - this property is cached + idx_t AllocationSize() const; //! Get the allocator DUCKDB_API Allocator &GetAllocator() const; @@ -13474,6 +13745,8 @@ struct StatementProperties { return_type(StatementReturnType::QUERY_RESULT), parameter_count(0), always_require_rebind(false) { } + //! The set of databases this statement will read from + unordered_set read_databases; //! The set of databases this statement will modify unordered_set modified_databases; //! Whether or not the statement requires a valid transaction. Almost all statements require this, with the @@ -13979,7 +14252,6 @@ enum class PhysicalOperatorType : uint8_t { PROJECTION, COPY_TO_FILE, BATCH_COPY_TO_FILE, - FIXED_BATCH_COPY_TO_FILE, RESERVOIR_SAMPLE, STREAMING_SAMPLE, STREAMING_WINDOW, @@ -14061,6 +14333,7 @@ enum class PhysicalOperatorType : uint8_t { RESULT_COLLECTOR, RESET, EXTENSION, + VERIFY_VECTOR, // ----------------------------- // Secret @@ -14585,7 +14858,6 @@ enum class LogicalOperatorType : uint8_t { LOGICAL_COPY_TO_FILE = 10, LOGICAL_DISTINCT = 11, LOGICAL_SAMPLE = 12, - LOGICAL_LIMIT_PERCENT = 13, LOGICAL_PIVOT = 14, LOGICAL_COPY_DATABASE = 15, @@ -15416,7 +15688,8 @@ class RelationManager { bool ExtractBindings(Expression &expression, unordered_set &bindings); void AddRelation(LogicalOperator &op, optional_ptr parent, const RelationStats &stats); - void AddAggregateRelation(LogicalOperator &op, optional_ptr parent, const RelationStats &stats); + void AddAggregateOrWindowRelation(LogicalOperator &op, optional_ptr parent, + const RelationStats &stats, LogicalOperatorType op_type); vector> GetRelations(); const vector GetRelationStats(); @@ -15582,7 +15855,7 @@ class OperatorState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -15599,7 +15872,7 @@ class GlobalOperatorState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -15620,7 +15893,7 @@ class GlobalSinkState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -15628,6 +15901,10 @@ class GlobalSinkState { D_ASSERT(dynamic_cast(this)); return reinterpret_cast(*this); } + + virtual idx_t MaxThreads(idx_t source_max_threads) { + return source_max_threads; + } }; class LocalSinkState { @@ -15640,7 +15917,7 @@ class LocalSinkState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -15661,7 +15938,7 @@ class GlobalSourceState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -15678,7 +15955,7 @@ class LocalSourceState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -16990,7 +17267,7 @@ struct TableFunctionInfo { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -17014,7 +17291,7 @@ struct GlobalTableFunctionState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -17029,7 +17306,7 @@ struct LocalTableFunctionState { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -17314,26 +17591,6 @@ class Task : public std::enable_shared_from_this { } }; -//! Execute a task within an executor, including exception handling -//! This should be used within queries -class ExecutorTask : public Task { -public: - ExecutorTask(Executor &executor); - ExecutorTask(ClientContext &context); - virtual ~ExecutorTask(); - -public: - void Deschedule() override; - void Reschedule() override; - -public: - Executor &executor; - -public: - virtual TaskExecutionResult ExecuteTask(TaskExecutionMode mode) = 0; - TaskExecutionResult Execute(TaskExecutionMode mode) override; -}; - } // namespace duckdb @@ -17416,13 +17673,141 @@ class TaskScheduler { vector>> markers; //! The threshold after which to flush the allocator after completing a task atomic allocator_flush_threshold; - //! Requested thread count - atomic thread_count; + //! Requested thread count (set by the 'threads' setting) + atomic requested_thread_count; + //! The amount of threads currently running + atomic current_thread_count; }; } // namespace duckdb +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/parallel/executor_task.hpp +// +// +//===----------------------------------------------------------------------===// + + + + +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/parallel/event.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + + + +namespace duckdb { +class Executor; +class Task; + +class Event : public std::enable_shared_from_this { +public: + explicit Event(Executor &executor); + virtual ~Event() = default; + +public: + virtual void Schedule() = 0; + //! Called right after the event is finished + virtual void FinishEvent() { + } + //! Called after the event is entirely finished + virtual void FinalizeFinish() { + } + + void FinishTask(); + void Finish(); + + void AddDependency(Event &event); + bool HasDependencies() const { + return total_dependencies != 0; + } + const vector> &GetParentsVerification() const; + + void CompleteDependency(); + + void SetTasks(vector> tasks); + + void InsertEvent(shared_ptr replacement_event); + + bool IsFinished() const { + return finished; + } + + virtual void PrintPipeline() { + } + + template + TARGET &Cast() { + DynamicCastCheck(this); + return reinterpret_cast(*this); + } + template + const TARGET &Cast() const { + D_ASSERT(dynamic_cast(this)); + return reinterpret_cast(*this); + } + +protected: + Executor &executor; + //! The current threads working on the event + atomic finished_tasks; + //! The maximum amount of threads that can work on the event + atomic total_tasks; + + //! The amount of completed dependencies + //! The event can only be started after the dependencies have finished executing + atomic finished_dependencies; + //! The total amount of dependencies + idx_t total_dependencies; + + //! The events that depend on this event to run + vector> parents; + //! Raw pointers to the parents (used for verification only) + vector> parents_raw; + + //! Whether or not the event is finished executing + atomic finished; +}; + +} // namespace duckdb + + +namespace duckdb { + +//! Execute a task within an executor, including exception handling +//! This should be used within queries +class ExecutorTask : public Task { +public: + ExecutorTask(Executor &executor, shared_ptr event); + ExecutorTask(ClientContext &context, shared_ptr event); + virtual ~ExecutorTask(); + +public: + void Deschedule() override; + void Reschedule() override; + +public: + Executor &executor; + shared_ptr event; + +public: + virtual TaskExecutionResult ExecuteTask(TaskExecutionMode mode) = 0; + TaskExecutionResult Execute(TaskExecutionMode mode) override; +}; + +} // namespace duckdb + namespace duckdb { @@ -17439,7 +17824,6 @@ class PipelineTask : public ExecutorTask { explicit PipelineTask(Pipeline &pipeline_p, shared_ptr event_p); Pipeline &pipeline; - shared_ptr event; unique_ptr pipeline_executor; public: @@ -17650,6 +18034,13 @@ class Executor { //! Returns true if all pipelines have been completed bool ExecutionIsFinished(); + void RegisterTask() { + executor_tasks++; + } + void UnregisterTask() { + executor_tasks--; + } + private: bool ResultCollectorIsBlocked(); void InitializeInternal(PhysicalOperator &physical_plan); @@ -17708,6 +18099,9 @@ class Executor { //! Task that have been descheduled unordered_map> to_be_rescheduled_tasks; + + //! Currently alive executor tasks + atomic executor_tasks; }; } // namespace duckdb @@ -18272,7 +18666,8 @@ enum class ParseInfoType : uint8_t { SHOW_SELECT_INFO, TRANSACTION_INFO, VACUUM_INFO, - COMMENT_ON_INFO + COMMENT_ON_INFO, + COMMENT_ON_COLUMN_INFO }; struct ParseInfo { @@ -18286,7 +18681,7 @@ struct ParseInfo { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } @@ -18376,6 +18771,8 @@ enum class CSVState : uint8_t; enum class CTEMaterialize : uint8_t; +enum class CatalogLookupBehavior : uint8_t; + enum class CatalogType : uint8_t; enum class CheckpointAbort : uint8_t; @@ -18458,6 +18855,8 @@ enum class JoinType : uint8_t; enum class KeywordCategory : uint8_t; +enum class LimitNodeType : uint8_t; + enum class LoadType : uint8_t; enum class LogicalOperatorType : uint8_t; @@ -18516,6 +18915,8 @@ enum class PragmaType : uint8_t; enum class PreparedParamType : uint8_t; +enum class PreparedStatementMode : uint8_t; + enum class ProfilerPrintFormat : uint8_t; enum class QuantileSerializationType : uint8_t; @@ -18546,6 +18947,8 @@ enum class SetScope : uint8_t; enum class SetType : uint8_t; +enum class SettingScope : uint8_t; + enum class ShowType : uint8_t; enum class SimplifiedTokenType : uint8_t; @@ -18673,6 +19076,9 @@ const char* EnumUtil::ToChars(CSVState value); template<> const char* EnumUtil::ToChars(CTEMaterialize value); +template<> +const char* EnumUtil::ToChars(CatalogLookupBehavior value); + template<> const char* EnumUtil::ToChars(CatalogType value); @@ -18796,6 +19202,9 @@ const char* EnumUtil::ToChars(JoinType value); template<> const char* EnumUtil::ToChars(KeywordCategory value); +template<> +const char* EnumUtil::ToChars(LimitNodeType value); + template<> const char* EnumUtil::ToChars(LoadType value); @@ -18883,6 +19292,9 @@ const char* EnumUtil::ToChars(PragmaType value); template<> const char* EnumUtil::ToChars(PreparedParamType value); +template<> +const char* EnumUtil::ToChars(PreparedStatementMode value); + template<> const char* EnumUtil::ToChars(ProfilerPrintFormat value); @@ -18928,6 +19340,9 @@ const char* EnumUtil::ToChars(SetScope value); template<> const char* EnumUtil::ToChars(SetType value); +template<> +const char* EnumUtil::ToChars(SettingScope value); + template<> const char* EnumUtil::ToChars(ShowType value); @@ -19088,6 +19503,9 @@ CSVState EnumUtil::FromString(const char *value); template<> CTEMaterialize EnumUtil::FromString(const char *value); +template<> +CatalogLookupBehavior EnumUtil::FromString(const char *value); + template<> CatalogType EnumUtil::FromString(const char *value); @@ -19211,6 +19629,9 @@ JoinType EnumUtil::FromString(const char *value); template<> KeywordCategory EnumUtil::FromString(const char *value); +template<> +LimitNodeType EnumUtil::FromString(const char *value); + template<> LoadType EnumUtil::FromString(const char *value); @@ -19298,6 +19719,9 @@ PragmaType EnumUtil::FromString(const char *value); template<> PreparedParamType EnumUtil::FromString(const char *value); +template<> +PreparedStatementMode EnumUtil::FromString(const char *value); + template<> ProfilerPrintFormat EnumUtil::FromString(const char *value); @@ -19343,6 +19767,9 @@ SetScope EnumUtil::FromString(const char *value); template<> SetType EnumUtil::FromString(const char *value); +template<> +SettingScope EnumUtil::FromString(const char *value); + template<> ShowType EnumUtil::FromString(const char *value); @@ -19606,7 +20033,8 @@ enum class AlterType : uint8_t { CHANGE_OWNERSHIP = 4, ALTER_SCALAR_FUNCTION = 5, ALTER_TABLE_FUNCTION = 6, - SET_COMMENT = 7 + SET_COMMENT = 7, + SET_COLUMN_COMMENT = 8 }; struct AlterEntryData { @@ -19943,30 +20371,6 @@ struct ChangeColumnTypeInfo : public AlterTableInfo { ChangeColumnTypeInfo(); }; -//===--------------------------------------------------------------------===// -// SetColumnCommentInfo -//===--------------------------------------------------------------------===// -struct SetColumnCommentInfo : public AlterTableInfo { - SetColumnCommentInfo(AlterEntryData data, string column_name, Value comment_value); - ~SetColumnCommentInfo() override; - - //! The column name to alter - string column_name; - //! The target type of the column - Value comment; - -public: - unique_ptr Copy() const override; - void Serialize(Serializer &serializer) const override; - static unique_ptr Deserialize(Deserializer &deserializer); - - string GetColumnName() const override { - return column_name; - }; - - explicit SetColumnCommentInfo(); -}; - //===--------------------------------------------------------------------===// // SetDefaultInfo //===--------------------------------------------------------------------===// @@ -20319,7 +20723,7 @@ class Transaction { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -20631,7 +21035,7 @@ using std::deque; //===----------------------------------------------------------------------===// // DuckDB // -// src/include/duckdb/parallel/interrupt.hpp +// duckdb/parallel/interrupt.hpp // // //===----------------------------------------------------------------------===// @@ -21101,74 +21505,77 @@ extern "C" { //===--------------------------------------------------------------------===// // Enums //===--------------------------------------------------------------------===// - +// WARNING: the numbers of these enums should not be changed, as changing the numbers breaks ABI compatibility +// Always add enums at the END of the enum //! An enum over DuckDB's internal types. typedef enum DUCKDB_TYPE { DUCKDB_TYPE_INVALID = 0, // bool - DUCKDB_TYPE_BOOLEAN, + DUCKDB_TYPE_BOOLEAN = 1, // int8_t - DUCKDB_TYPE_TINYINT, + DUCKDB_TYPE_TINYINT = 2, // int16_t - DUCKDB_TYPE_SMALLINT, + DUCKDB_TYPE_SMALLINT = 3, // int32_t - DUCKDB_TYPE_INTEGER, + DUCKDB_TYPE_INTEGER = 4, // int64_t - DUCKDB_TYPE_BIGINT, + DUCKDB_TYPE_BIGINT = 5, // uint8_t - DUCKDB_TYPE_UTINYINT, + DUCKDB_TYPE_UTINYINT = 6, // uint16_t - DUCKDB_TYPE_USMALLINT, + DUCKDB_TYPE_USMALLINT = 7, // uint32_t - DUCKDB_TYPE_UINTEGER, + DUCKDB_TYPE_UINTEGER = 8, // uint64_t - DUCKDB_TYPE_UBIGINT, + DUCKDB_TYPE_UBIGINT = 9, // float - DUCKDB_TYPE_FLOAT, + DUCKDB_TYPE_FLOAT = 10, // double - DUCKDB_TYPE_DOUBLE, + DUCKDB_TYPE_DOUBLE = 11, // duckdb_timestamp, in microseconds - DUCKDB_TYPE_TIMESTAMP, + DUCKDB_TYPE_TIMESTAMP = 12, // duckdb_date - DUCKDB_TYPE_DATE, + DUCKDB_TYPE_DATE = 13, // duckdb_time - DUCKDB_TYPE_TIME, + DUCKDB_TYPE_TIME = 14, // duckdb_interval - DUCKDB_TYPE_INTERVAL, + DUCKDB_TYPE_INTERVAL = 15, // duckdb_hugeint - DUCKDB_TYPE_HUGEINT, + DUCKDB_TYPE_HUGEINT = 16, // duckdb_uhugeint - DUCKDB_TYPE_UHUGEINT, + DUCKDB_TYPE_UHUGEINT = 32, // const char* - DUCKDB_TYPE_VARCHAR, + DUCKDB_TYPE_VARCHAR = 17, // duckdb_blob - DUCKDB_TYPE_BLOB, + DUCKDB_TYPE_BLOB = 18, // decimal - DUCKDB_TYPE_DECIMAL, + DUCKDB_TYPE_DECIMAL = 19, // duckdb_timestamp, in seconds - DUCKDB_TYPE_TIMESTAMP_S, + DUCKDB_TYPE_TIMESTAMP_S = 20, // duckdb_timestamp, in milliseconds - DUCKDB_TYPE_TIMESTAMP_MS, + DUCKDB_TYPE_TIMESTAMP_MS = 21, // duckdb_timestamp, in nanoseconds - DUCKDB_TYPE_TIMESTAMP_NS, + DUCKDB_TYPE_TIMESTAMP_NS = 22, // enum type, only useful as logical type - DUCKDB_TYPE_ENUM, + DUCKDB_TYPE_ENUM = 23, // list type, only useful as logical type - DUCKDB_TYPE_LIST, + DUCKDB_TYPE_LIST = 24, // struct type, only useful as logical type - DUCKDB_TYPE_STRUCT, + DUCKDB_TYPE_STRUCT = 25, // map type, only useful as logical type - DUCKDB_TYPE_MAP, + DUCKDB_TYPE_MAP = 26, + // duckdb_array, only useful as logical type + DUCKDB_TYPE_ARRAY = 33, // duckdb_hugeint - DUCKDB_TYPE_UUID, + DUCKDB_TYPE_UUID = 27, // union type, only useful as logical type - DUCKDB_TYPE_UNION, + DUCKDB_TYPE_UNION = 28, // duckdb_bit - DUCKDB_TYPE_BIT, + DUCKDB_TYPE_BIT = 29, // duckdb_time_tz - DUCKDB_TYPE_TIME_TZ, + DUCKDB_TYPE_TIME_TZ = 30, // duckdb_timestamp - DUCKDB_TYPE_TIMESTAMP_TZ, + DUCKDB_TYPE_TIMESTAMP_TZ = 31, } duckdb_type; //! An enum over the returned state of different functions. typedef enum { DuckDBSuccess = 0, DuckDBError = 1 } duckdb_state; @@ -21181,41 +21588,41 @@ typedef enum { } duckdb_pending_state; //! An enum over DuckDB's different result types. typedef enum { - DUCKDB_RESULT_TYPE_INVALID, - DUCKDB_RESULT_TYPE_CHANGED_ROWS, - DUCKDB_RESULT_TYPE_NOTHING, - DUCKDB_RESULT_TYPE_QUERY_RESULT, + DUCKDB_RESULT_TYPE_INVALID = 0, + DUCKDB_RESULT_TYPE_CHANGED_ROWS = 1, + DUCKDB_RESULT_TYPE_NOTHING = 2, + DUCKDB_RESULT_TYPE_QUERY_RESULT = 3, } duckdb_result_type; //! An enum over DuckDB's different statement types. typedef enum { - DUCKDB_STATEMENT_TYPE_INVALID, - DUCKDB_STATEMENT_TYPE_SELECT, - DUCKDB_STATEMENT_TYPE_INSERT, - DUCKDB_STATEMENT_TYPE_UPDATE, - DUCKDB_STATEMENT_TYPE_EXPLAIN, - DUCKDB_STATEMENT_TYPE_DELETE, - DUCKDB_STATEMENT_TYPE_PREPARE, - DUCKDB_STATEMENT_TYPE_CREATE, - DUCKDB_STATEMENT_TYPE_EXECUTE, - DUCKDB_STATEMENT_TYPE_ALTER, - DUCKDB_STATEMENT_TYPE_TRANSACTION, - DUCKDB_STATEMENT_TYPE_COPY, - DUCKDB_STATEMENT_TYPE_ANALYZE, - DUCKDB_STATEMENT_TYPE_VARIABLE_SET, - DUCKDB_STATEMENT_TYPE_CREATE_FUNC, - DUCKDB_STATEMENT_TYPE_DROP, - DUCKDB_STATEMENT_TYPE_EXPORT, - DUCKDB_STATEMENT_TYPE_PRAGMA, - DUCKDB_STATEMENT_TYPE_VACUUM, - DUCKDB_STATEMENT_TYPE_CALL, - DUCKDB_STATEMENT_TYPE_SET, - DUCKDB_STATEMENT_TYPE_LOAD, - DUCKDB_STATEMENT_TYPE_RELATION, - DUCKDB_STATEMENT_TYPE_EXTENSION, - DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN, - DUCKDB_STATEMENT_TYPE_ATTACH, - DUCKDB_STATEMENT_TYPE_DETACH, - DUCKDB_STATEMENT_TYPE_MULTI, + DUCKDB_STATEMENT_TYPE_INVALID = 0, + DUCKDB_STATEMENT_TYPE_SELECT = 1, + DUCKDB_STATEMENT_TYPE_INSERT = 2, + DUCKDB_STATEMENT_TYPE_UPDATE = 3, + DUCKDB_STATEMENT_TYPE_EXPLAIN = 4, + DUCKDB_STATEMENT_TYPE_DELETE = 5, + DUCKDB_STATEMENT_TYPE_PREPARE = 6, + DUCKDB_STATEMENT_TYPE_CREATE = 7, + DUCKDB_STATEMENT_TYPE_EXECUTE = 8, + DUCKDB_STATEMENT_TYPE_ALTER = 9, + DUCKDB_STATEMENT_TYPE_TRANSACTION = 10, + DUCKDB_STATEMENT_TYPE_COPY = 11, + DUCKDB_STATEMENT_TYPE_ANALYZE = 12, + DUCKDB_STATEMENT_TYPE_VARIABLE_SET = 13, + DUCKDB_STATEMENT_TYPE_CREATE_FUNC = 14, + DUCKDB_STATEMENT_TYPE_DROP = 15, + DUCKDB_STATEMENT_TYPE_EXPORT = 16, + DUCKDB_STATEMENT_TYPE_PRAGMA = 17, + DUCKDB_STATEMENT_TYPE_VACUUM = 18, + DUCKDB_STATEMENT_TYPE_CALL = 19, + DUCKDB_STATEMENT_TYPE_SET = 20, + DUCKDB_STATEMENT_TYPE_LOAD = 21, + DUCKDB_STATEMENT_TYPE_RELATION = 22, + DUCKDB_STATEMENT_TYPE_EXTENSION = 23, + DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN = 24, + DUCKDB_STATEMENT_TYPE_ATTACH = 25, + DUCKDB_STATEMENT_TYPE_DETACH = 26, + DUCKDB_STATEMENT_TYPE_MULTI = 27, } duckdb_statement_type; //===--------------------------------------------------------------------===// @@ -21264,7 +21671,7 @@ typedef struct { uint64_t bits; } duckdb_time_tz; typedef struct { - duckdb_time time; + duckdb_time_struct time; int32_t offset; } duckdb_time_tz_struct; @@ -22662,6 +23069,16 @@ Creates a list value from a type and an array of values of length `value_count` */ DUCKDB_API duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count); +/*! +Creates a array value from a type and an array of values of length `value_count` + +* type: The type of the array +* values: The values for the array +* value_count: The number of values in the array +* returns: The value. This must be destroyed with `duckdb_destroy_value`. +*/ +DUCKDB_API duckdb_value duckdb_create_array_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count); + /*! Obtains a string representation of the given value. The result must be destroyed with `duckdb_free`. @@ -22712,6 +23129,16 @@ The resulting type should be destroyed with `duckdb_destroy_logical_type`. */ DUCKDB_API duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type); +/*! +Creates a array type from its child type. +The resulting type should be destroyed with `duckdb_destroy_logical_type`. + +* type: The child type of array type to create. +* array_size: The number of elements in the array. +* returns: The logical type. +*/ +DUCKDB_API duckdb_logical_type duckdb_create_array_type(duckdb_logical_type type, idx_t array_size); + /*! Creates a map type from its key type and value type. The resulting type should be destroyed with `duckdb_destroy_logical_type`. @@ -22834,6 +23261,24 @@ The result must be freed with `duckdb_destroy_logical_type`. */ DUCKDB_API duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type); +/*! +Retrieves the child type of the given array type. + +The result must be freed with `duckdb_destroy_logical_type`. + +* type: The logical type object +* returns: The child type of the array type. Must be destroyed with `duckdb_destroy_logical_type`. +*/ +DUCKDB_API duckdb_logical_type duckdb_array_type_child_type(duckdb_logical_type type); + +/*! +Retrieves the array size of the given array type. + +* type: The logical type object +* returns: The fixed number of elements the values of this array type can store. +*/ +DUCKDB_API idx_t duckdb_array_type_array_size(duckdb_logical_type type); + /*! Retrieves the key type of the given map type. @@ -23052,7 +23497,7 @@ Assigns a string element in the vector at the specified location. DUCKDB_API void duckdb_vector_assign_string_element(duckdb_vector vector, idx_t index, const char *str); /*! -Assigns a string element in the vector at the specified location. +Assigns a string element in the vector at the specified location. You may also use this function to assign BLOBs. * vector: The vector to alter * index: The row position in the vector to assign the string to @@ -23109,6 +23554,17 @@ The resulting vector is valid as long as the parent vector is valid. */ DUCKDB_API duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index); +/*! +Retrieves the child vector of a array vector. + +The resulting vector is valid as long as the parent vector is valid. +The resulting vector has the size of the parent vector multiplied by the array size. + +* vector: The vector +* returns: The child vector +*/ +DUCKDB_API duckdb_vector duckdb_array_vector_get_child(duckdb_vector vector); + //===--------------------------------------------------------------------===// // Validity Mask Functions //===--------------------------------------------------------------------===// @@ -24194,6 +24650,8 @@ struct ClientConfig { idx_t perfect_ht_threshold = 12; //! The maximum number of rows to accumulate before sorting ordered aggregates. idx_t ordered_aggregate_threshold = (idx_t(1) << 18); + //! The number of rows to accumulate before flushing during a partitioned write + idx_t partitioned_write_flush_threshold = idx_t(1) << idx_t(19); //! Callback to create a progress bar display progress_bar_display_create_func_t display_create_func = nullptr; @@ -24233,6 +24691,27 @@ struct ClientConfig { +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/common/enums/prepared_statement_mode.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + +namespace duckdb { + +enum class PreparedStatementMode : uint8_t { + PREPARE_ONLY, + PREPARE_AND_EXECUTE, +}; + +} // namespace duckdb + //===----------------------------------------------------------------------===// // DuckDB @@ -24246,9 +24725,15 @@ struct ClientConfig { + namespace duckdb { class ClientContext; +class ErrorData; class MetaTransaction; +class PreparedStatementData; +class SQLStatement; + +enum class RebindQueryInfo { DO_NOT_REBIND, ATTEMPT_TO_REBIND }; //! ClientContextState is virtual base class for ClientContext-local (or Query-Local, using QueryEnd callback) state //! e.g. caches that need to live as long as a ClientContext or Query. @@ -24268,6 +24753,677 @@ class ClientContextState { } virtual void TransactionRollback(MetaTransaction &transaction, ClientContext &context) { } + virtual bool CanRequestRebind() { + return false; + } + virtual RebindQueryInfo OnPlanningError(ClientContext &context, SQLStatement &statement, ErrorData &error) { + return RebindQueryInfo::DO_NOT_REBIND; + } + virtual RebindQueryInfo OnFinalizePrepare(ClientContext &context, PreparedStatementData &prepared_statement, + PreparedStatementMode mode) { + return RebindQueryInfo::DO_NOT_REBIND; + } + virtual RebindQueryInfo OnExecutePrepared(ClientContext &context, PreparedStatementData &prepared_statement, + RebindQueryInfo current_rebind) { + return RebindQueryInfo::DO_NOT_REBIND; + } +}; + +} // namespace duckdb + +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/main/settings.hpp +// +// +//===----------------------------------------------------------------------===// + + + + + + +namespace duckdb { +class ClientContext; +class DatabaseInstance; +struct DBConfig; + +const string GetDefaultUserAgent(); + +enum class SettingScope : uint8_t { GLOBAL, LOCAL, INVALID }; + +struct SettingLookupResult { +public: + SettingLookupResult() : scope(SettingScope::INVALID) { + } + SettingLookupResult(SettingScope scope) : scope(scope) { + D_ASSERT(scope != SettingScope::INVALID); + } + +public: + operator bool() { + return scope != SettingScope::INVALID; + } + +public: + SettingScope GetScope() { + D_ASSERT(scope != SettingScope::INVALID); + return scope; + } + +private: + SettingScope scope = SettingScope::INVALID; +}; + +struct AccessModeSetting { + static constexpr const char *Name = "access_mode"; + static constexpr const char *Description = "Access mode of the database (AUTOMATIC, READ_ONLY or READ_WRITE)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct AllowPersistentSecrets { + static constexpr const char *Name = "allow_persistent_secrets"; + static constexpr const char *Description = + "Allow the creation of persistent secrets, that are stored and loaded on restarts"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct CheckpointThresholdSetting { + static constexpr const char *Name = "checkpoint_threshold"; + static constexpr const char *Description = + "The WAL size threshold at which to automatically trigger a checkpoint (e.g. 1GB)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct DebugCheckpointAbort { + static constexpr const char *Name = "debug_checkpoint_abort"; + static constexpr const char *Description = + "DEBUG SETTING: trigger an abort while checkpointing for testing purposes"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct DebugForceExternal { + static constexpr const char *Name = "debug_force_external"; + static constexpr const char *Description = + "DEBUG SETTING: force out-of-core computation for operators that support it, used for testing"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct DebugForceNoCrossProduct { + static constexpr const char *Name = "debug_force_no_cross_product"; + static constexpr const char *Description = + "DEBUG SETTING: Force disable cross product generation when hyper graph isn't connected, used for testing"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct OrderedAggregateThreshold { + static constexpr const char *Name = "ordered_aggregate_threshold"; // NOLINT + static constexpr const char *Description = // NOLINT + "The number of rows to accumulate before sorting, used for tuning"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT; // NOLINT + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct DebugAsOfIEJoin { + static constexpr const char *Name = "debug_asof_iejoin"; // NOLINT + static constexpr const char *Description = "DEBUG SETTING: force use of IEJoin to implement AsOf joins"; // NOLINT + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; // NOLINT + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct PreferRangeJoins { + static constexpr const char *Name = "prefer_range_joins"; // NOLINT + static constexpr const char *Description = "Force use of range joins with mixed predicates"; // NOLINT + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; // NOLINT + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct DebugWindowMode { + static constexpr const char *Name = "debug_window_mode"; + static constexpr const char *Description = "DEBUG SETTING: switch window mode to use"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct DefaultCollationSetting { + static constexpr const char *Name = "default_collation"; + static constexpr const char *Description = "The collation setting used when none is specified"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct DefaultOrderSetting { + static constexpr const char *Name = "default_order"; + static constexpr const char *Description = "The order type used when none is specified (ASC or DESC)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct DefaultNullOrderSetting { + static constexpr const char *Name = "default_null_order"; + static constexpr const char *Description = "Null ordering used when none is specified (NULLS_FIRST or NULLS_LAST)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct DefaultSecretStorage { + static constexpr const char *Name = "default_secret_storage"; + static constexpr const char *Description = "Allows switching the default storage for secrets"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct DisabledFileSystemsSetting { + static constexpr const char *Name = "disabled_filesystems"; + static constexpr const char *Description = "Disable specific file systems preventing access (e.g. LocalFileSystem)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct DisabledOptimizersSetting { + static constexpr const char *Name = "disabled_optimizers"; + static constexpr const char *Description = "DEBUG SETTING: disable a specific set of optimizers (comma separated)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct EnableExternalAccessSetting { + static constexpr const char *Name = "enable_external_access"; + static constexpr const char *Description = + "Allow the database to access external state (through e.g. loading/installing modules, COPY TO/FROM, CSV " + "readers, pandas replacement scans, etc)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct EnableFSSTVectors { + static constexpr const char *Name = "enable_fsst_vectors"; + static constexpr const char *Description = + "Allow scans on FSST compressed segments to emit compressed vectors to utilize late decompression"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct AllowUnsignedExtensionsSetting { + static constexpr const char *Name = "allow_unsigned_extensions"; + static constexpr const char *Description = "Allow to load extensions with invalid or missing signatures"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct AllowUnredactedSecretsSetting { + static constexpr const char *Name = "allow_unredacted_secrets"; + static constexpr const char *Description = "Allow printing unredacted secrets"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct CustomExtensionRepository { + static constexpr const char *Name = "custom_extension_repository"; + static constexpr const char *Description = "Overrides the custom endpoint for remote extension installation"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct AutoloadExtensionRepository { + static constexpr const char *Name = "autoinstall_extension_repository"; + static constexpr const char *Description = + "Overrides the custom endpoint for extension installation on autoloading"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct AutoinstallKnownExtensions { + static constexpr const char *Name = "autoinstall_known_extensions"; + static constexpr const char *Description = + "Whether known extensions are allowed to be automatically installed when a query depends on them"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct AutoloadKnownExtensions { + static constexpr const char *Name = "autoload_known_extensions"; + static constexpr const char *Description = + "Whether known extensions are allowed to be automatically loaded when a query depends on them"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct EnableObjectCacheSetting { + static constexpr const char *Name = "enable_object_cache"; + static constexpr const char *Description = "Whether or not object cache is used to cache e.g. Parquet metadata"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct EnableHTTPMetadataCacheSetting { + static constexpr const char *Name = "enable_http_metadata_cache"; + static constexpr const char *Description = "Whether or not the global http metadata is used to cache HTTP metadata"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static Value GetSetting(ClientContext &context); +}; + +struct EnableProfilingSetting { + static constexpr const char *Name = "enable_profiling"; + static constexpr const char *Description = + "Enables profiling, and sets the output format (JSON, QUERY_TREE, QUERY_TREE_OPTIMIZER)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct EnableProgressBarSetting { + static constexpr const char *Name = "enable_progress_bar"; + static constexpr const char *Description = + "Enables the progress bar, printing progress to the terminal for long queries"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct EnableProgressBarPrintSetting { + static constexpr const char *Name = "enable_progress_bar_print"; + static constexpr const char *Description = + "Controls the printing of the progress bar, when 'enable_progress_bar' is true"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct ErrorsAsJsonSetting { + static constexpr const char *Name = "errors_as_json"; + static constexpr const char *Description = "Output error messages as structured JSON instead of as a raw string"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct ExplainOutputSetting { + static constexpr const char *Name = "explain_output"; + static constexpr const char *Description = "Output of EXPLAIN statements (ALL, OPTIMIZED_ONLY, PHYSICAL_ONLY)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct ExportLargeBufferArrow { + 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"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct ExtensionDirectorySetting { + static constexpr const char *Name = "extension_directory"; + static constexpr const char *Description = "Set the directory to store extensions in"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct ExternalThreadsSetting { + static constexpr const char *Name = "external_threads"; + static constexpr const char *Description = "The number of external threads that work on DuckDB tasks."; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct FileSearchPathSetting { + static constexpr const char *Name = "file_search_path"; + static constexpr const char *Description = "A comma separated list of directories to search for input files"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct ForceCompressionSetting { + static constexpr const char *Name = "force_compression"; + static constexpr const char *Description = "DEBUG SETTING: forces a specific compression method to be used"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct ForceBitpackingModeSetting { + static constexpr const char *Name = "force_bitpacking_mode"; + static constexpr const char *Description = "DEBUG SETTING: forces a specific bitpacking mode"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct HomeDirectorySetting { + static constexpr const char *Name = "home_directory"; + static constexpr const char *Description = "Sets the home directory used by the system"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct IntegerDivisionSetting { + static constexpr const char *Name = "integer_division"; + static constexpr const char *Description = + "Whether or not the / operator defaults to integer division, or to floating point division"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct LogQueryPathSetting { + static constexpr const char *Name = "log_query_path"; + static constexpr const char *Description = + "Specifies the path to which queries should be logged (default: empty string, queries are not logged)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct LockConfigurationSetting { + static constexpr const char *Name = "lock_configuration"; + static constexpr const char *Description = "Whether or not the configuration can be altered"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct ImmediateTransactionModeSetting { + static constexpr const char *Name = "immediate_transaction_mode"; + static constexpr const char *Description = + "Whether transactions should be started lazily when needed, or immediately when BEGIN TRANSACTION is called"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct MaximumExpressionDepthSetting { + static constexpr const char *Name = "max_expression_depth"; + static constexpr const char *Description = + "The maximum expression depth limit in the parser. WARNING: increasing this setting and using very deep " + "expressions might lead to stack overflow errors."; + static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct MaximumMemorySetting { + static constexpr const char *Name = "max_memory"; + static constexpr const char *Description = "The maximum memory of the system (e.g. 1GB)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct OldImplicitCasting { + static constexpr const char *Name = "old_implicit_casting"; + static constexpr const char *Description = "Allow implicit casting to/from VARCHAR"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct PartitionedWriteFlushThreshold { + static constexpr const char *Name = "partitioned_write_flush_threshold"; + static constexpr const char *Description = + "The threshold in number of rows after which we flush a thread state when writing using PARTITION_BY"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct PasswordSetting { + static constexpr const char *Name = "password"; + static constexpr const char *Description = "The password to use. Ignored for legacy compatibility."; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct PerfectHashThresholdSetting { + static constexpr const char *Name = "perfect_ht_threshold"; + static constexpr const char *Description = "Threshold in bytes for when to use a perfect hash table (default: 12)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct PivotFilterThreshold { + static constexpr const char *Name = "pivot_filter_threshold"; + static constexpr const char *Description = + "The threshold to switch from using filtered aggregates to LIST with a dedicated pivot operator"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct PivotLimitSetting { + static constexpr const char *Name = "pivot_limit"; + static constexpr const char *Description = + "The maximum number of pivot columns in a pivot statement (default: 100000)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct PreserveIdentifierCase { + static constexpr const char *Name = "preserve_identifier_case"; + static constexpr const char *Description = + "Whether or not to preserve the identifier case, instead of always lowercasing all non-quoted identifiers"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct PreserveInsertionOrder { + static constexpr const char *Name = "preserve_insertion_order"; + static constexpr const char *Description = + "Whether or not to preserve insertion order. If set to false the system is allowed to re-order any results " + "that do not contain ORDER BY clauses."; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct ProfileOutputSetting { + static constexpr const char *Name = "profile_output"; + static constexpr const char *Description = + "The file to which profile output should be saved, or empty to print to the terminal"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct ProfilingModeSetting { + static constexpr const char *Name = "profiling_mode"; + static constexpr const char *Description = "The profiling mode (STANDARD or DETAILED)"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct ProgressBarTimeSetting { + static constexpr const char *Name = "progress_bar_time"; + static constexpr const char *Description = + "Sets the time (in milliseconds) how long a query needs to take before we start printing a progress bar"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct SchemaSetting { + static constexpr const char *Name = "schema"; + static constexpr const char *Description = + "Sets the default search schema. Equivalent to setting search_path to a single value."; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct SearchPathSetting { + static constexpr const char *Name = "search_path"; + static constexpr const char *Description = + "Sets the default catalog search path as a comma-separated list of values"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetLocal(ClientContext &context, const Value ¶meter); + static void ResetLocal(ClientContext &context); + static Value GetSetting(ClientContext &context); +}; + +struct SecretDirectorySetting { + static constexpr const char *Name = "secret_directory"; + static constexpr const char *Description = "Set the directory to which persistent secrets are stored"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct TempDirectorySetting { + static constexpr const char *Name = "temp_directory"; + static constexpr const char *Description = "Set the directory to which to write temp files"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct ThreadsSetting { + static constexpr const char *Name = "threads"; + static constexpr const char *Description = "The number of total threads used by the system."; + static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct UsernameSetting { + static constexpr const char *Name = "username"; + static constexpr const char *Description = "The username to use. Ignored for legacy compatibility."; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct FlushAllocatorSetting { + static constexpr const char *Name = "allocator_flush_threshold"; + static constexpr const char *Description = + "Peak allocation threshold at which to flush the allocator after completing a task."; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct DuckDBApiSetting { + static constexpr const char *Name = "duckdb_api"; + static constexpr const char *Description = "DuckDB API surface"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); +}; + +struct CustomUserAgentSetting { + static constexpr const char *Name = "custom_user_agent"; + static constexpr const char *Description = "Metadata from DuckDB callers"; + static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR; + static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); + static void ResetGlobal(DatabaseInstance *db, DBConfig &config); + static Value GetSetting(ClientContext &context); }; } // namespace duckdb @@ -24411,7 +25567,7 @@ class ClientContext : public std::enable_shared_from_this { bool requires_valid_transaction = true); //! Equivalent to CURRENT_SETTING(key) SQL function. - DUCKDB_API bool TryGetCurrentSetting(const std::string &key, Value &result); + DUCKDB_API SettingLookupResult TryGetCurrentSetting(const std::string &key, Value &result); //! Returns the parser options for this client context DUCKDB_API ParserOptions GetParserOptions() const; @@ -24460,14 +25616,19 @@ class ClientContext : public std::enable_shared_from_this { unique_ptr statement, shared_ptr &prepared, const PendingQueryParameters ¶meters); - unique_ptr PendingPreparedStatement(ClientContextLock &lock, + unique_ptr PendingPreparedStatement(ClientContextLock &lock, const string &query, shared_ptr statement_p, const PendingQueryParameters ¶meters); + unique_ptr PendingPreparedStatementInternal(ClientContextLock &lock, + shared_ptr statement_p, + const PendingQueryParameters ¶meters); + void CheckIfPreparedStatementIsExecutable(PreparedStatementData &statement); //! Internally prepare a SQL statement. Caller must hold the context_lock. shared_ptr CreatePreparedStatement(ClientContextLock &lock, const string &query, unique_ptr statement, - optional_ptr> values = nullptr); + optional_ptr> values = nullptr, + PreparedStatementMode mode = PreparedStatementMode::PREPARE_ONLY); unique_ptr PendingStatementInternal(ClientContextLock &lock, const string &query, unique_ptr statement, const PendingQueryParameters ¶meters); @@ -24497,9 +25658,16 @@ class ClientContext : public std::enable_shared_from_this { unique_ptr PendingQueryInternal(ClientContextLock &, const shared_ptr &relation, bool allow_stream_result); + void RebindPreparedStatement(ClientContextLock &lock, const string &query, + shared_ptr &prepared, const PendingQueryParameters ¶meters); + template unique_ptr ErrorResult(ErrorData error, const string &query = string()); + shared_ptr + CreatePreparedStatementInternal(ClientContextLock &lock, const string &query, unique_ptr statement, + optional_ptr> values); + private: //! Lock on using the ClientContext in parallel mutex context_lock; @@ -24855,7 +26023,7 @@ class Relation : public std::enable_shared_from_this { public: template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -25260,7 +26428,7 @@ struct BindCastInfo { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -25278,7 +26446,7 @@ struct BoundCastData { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -25291,13 +26459,17 @@ struct BoundCastData { struct CastParameters { CastParameters() { } + CastParameters(bool strict, string *error_message) : CastParameters(nullptr, strict, error_message, nullptr) { + } CastParameters(BoundCastData *cast_data, bool strict, string *error_message, - optional_ptr local_state) - : cast_data(cast_data), strict(strict), error_message(error_message), local_state(local_state) { + optional_ptr local_state, bool nullify_parent_p = false) + : cast_data(cast_data), strict(strict), error_message(error_message), local_state(local_state), + nullify_parent(nullify_parent_p) { } CastParameters(CastParameters &parent, optional_ptr cast_data, optional_ptr local_state) - : cast_data(cast_data), strict(parent.strict), error_message(parent.error_message), local_state(local_state) { + : cast_data(cast_data), strict(parent.strict), error_message(parent.error_message), local_state(local_state), + query_location(parent.query_location) { } //! The bound cast data (if any) @@ -25308,6 +26480,10 @@ struct CastParameters { string *error_message = nullptr; //! Local state optional_ptr local_state; + //! Query location (if any) + optional_idx query_location; + //! In the case of a nested type, when facing a cast error, if we nullify the parent + bool nullify_parent = false; }; struct CastLocalStateParameters { @@ -25349,6 +26525,7 @@ struct BindCastInput { CastFunctionSet &function_set; optional_ptr info; optional_ptr context; + optional_idx query_location; public: DUCKDB_API BoundCastInfo GetCastFunction(const LogicalType &source, const LogicalType &target); @@ -25613,56 +26790,6 @@ class ParserExtension { -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/planner/operator/logical_limit_percent.hpp -// -// -//===----------------------------------------------------------------------===// - - - - - -namespace duckdb { - -//! LogicalLimitPercent represents a LIMIT PERCENT clause -class LogicalLimitPercent : public LogicalOperator { -public: - static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_LIMIT_PERCENT; - -public: - LogicalLimitPercent(double limit_percent, int64_t offset_val, unique_ptr limit, - unique_ptr offset) - : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT_PERCENT), limit_percent(limit_percent), - offset_val(offset_val), limit(std::move(limit)), offset(std::move(offset)) { - } - - //! Limit percent and offset values in case they are constants, used in optimizations. - double limit_percent; - int64_t offset_val; - //! The maximum amount of elements to emit - unique_ptr limit; - //! The offset from the start to begin emitting elements - unique_ptr offset; - -public: - vector GetColumnBindings() override { - return children[0]->GetColumnBindings(); - } - - void Serialize(Serializer &serializer) const override; - static unique_ptr Deserialize(Deserializer &deserializer); - idx_t EstimateCardinality(ClientContext &context) override; - -protected: - void ResolveTypes() override { - types = children[0]->types; - } -}; -} // namespace duckdb - //===----------------------------------------------------------------------===// // DuckDB // @@ -25853,7 +26980,6 @@ class PhysicalPlanGenerator { unique_ptr CreatePlan(LogicalFilter &op); unique_ptr CreatePlan(LogicalGet &op); unique_ptr CreatePlan(LogicalLimit &op); - unique_ptr CreatePlan(LogicalLimitPercent &op); unique_ptr CreatePlan(LogicalOrder &op); unique_ptr CreatePlan(LogicalTopN &op); unique_ptr CreatePlan(LogicalPositionalJoin &op); @@ -26335,6 +27461,9 @@ struct BoundCreateFunctionInfo; struct CommonTableExpressionInfo; struct BoundParameterMap; struct BoundPragmaInfo; +struct BoundLimitNode; +struct PivotColumnEntry; +struct UnpivotEntry; enum class BindingMode : uint8_t { STANDARD_BINDING, EXTRACT_NAMES }; @@ -26489,10 +27618,12 @@ class Binder : public std::enable_shared_from_this { unordered_set table_names; //! The set of bound views reference_set_t bound_views; + //! Unnamed subquery index + idx_t unnamed_subquery_index = 1; private: //! Get the root binder (binder with no parent) - Binder *GetRootBinder(); + Binder &GetRootBinder(); //! Determine the depth of the binder idx_t GetBinderDepth() const; //! Bind the expressions of generated columns to check for errors @@ -26500,9 +27631,8 @@ class Binder : public std::enable_shared_from_this { //! Bind the default values of the columns of a table void BindDefaultValues(const ColumnList &columns, vector> &bound_defaults); //! Bind a limit value (LIMIT or OFFSET) - unique_ptr BindDelimiter(ClientContext &context, OrderBinder &order_binder, - unique_ptr delimiter, const LogicalType &type, - Value &delimiter_value); + BoundLimitNode BindLimitValue(OrderBinder &order_binder, unique_ptr limit_val, bool is_percentage, + bool is_offset); //! Move correlated expressions from the child binder to this binder void MoveCorrelatedExpressions(Binder &other); @@ -26557,6 +27687,7 @@ class Binder : public std::enable_shared_from_this { unique_ptr CreatePlan(BoundSetOperationNode &node); unique_ptr CreatePlan(BoundQueryNode &node); + unique_ptr BindJoin(Binder &parent, TableRef &ref); unique_ptr Bind(BaseTableRef &ref); unique_ptr Bind(JoinRef &ref); unique_ptr Bind(SubqueryRef &ref, optional_ptr cte = nullptr); @@ -26571,6 +27702,8 @@ class Binder : public std::enable_shared_from_this { vector> all_columns, unique_ptr &where_clause); unique_ptr BindBoundPivot(PivotRef &expr); + void ExtractUnpivotEntries(Binder &child_binder, PivotColumnEntry &entry, vector &unpivot_entries); + void ExtractUnpivotColumnName(ParsedExpression &expr, vector &result); bool BindTableFunctionParameters(TableFunctionCatalogEntry &table_function, vector> &expressions, vector &arguments, @@ -27137,6 +28270,7 @@ class Extension { } // namespace duckdb + namespace duckdb { class BufferManager; class DatabaseManager; @@ -27175,9 +28309,9 @@ class DatabaseInstance : public std::enable_shared_from_this { DUCKDB_API static DatabaseInstance &GetDatabase(ClientContext &context); DUCKDB_API const unordered_set &LoadedExtensions(); - DUCKDB_API bool ExtensionIsLoaded(const std::string &name); + DUCKDB_API bool ExtensionIsLoaded(const string &name); - DUCKDB_API bool TryGetCurrentSetting(const std::string &key, Value &result); + DUCKDB_API SettingLookupResult TryGetCurrentSetting(const string &key, Value &result); unique_ptr CreateAttachedDatabase(ClientContext &context, const AttachInfo &info, const string &type, AccessMode access_mode); @@ -29782,6 +30916,7 @@ struct ArrowConverter { namespace duckdb { +struct CastParameters; //! The Blob class is a static class that holds helper functions for the Blob type. class Blob { @@ -29805,13 +30940,15 @@ class Blob { DUCKDB_API static string ToString(string_t blob); //! Returns the blob size of a string -> blob conversion - DUCKDB_API static bool TryGetBlobSize(string_t str, idx_t &result_size, string *error_message); + DUCKDB_API static bool TryGetBlobSize(string_t str, idx_t &result_size, CastParameters ¶meters); DUCKDB_API static idx_t GetBlobSize(string_t str); + DUCKDB_API static idx_t GetBlobSize(string_t str, CastParameters ¶meters); //! Convert a string to a blob. This function should ONLY be called after calling GetBlobSize, since it does NOT //! perform data validation. DUCKDB_API static void ToBlob(string_t str, data_ptr_t output); //! Convert a string object to a blob DUCKDB_API static string ToBlob(string_t str); + DUCKDB_API static string ToBlob(string_t str, CastParameters ¶meters); // base 64 conversion functions //! Returns the string size of a blob -> base64 conversion @@ -30124,6 +31261,9 @@ class UUID { //! Convert a hugeint object to a uuid style string static void ToString(hugeint_t input, char *buf); + //! Convert a uhugeint_t object to a uuid value + static hugeint_t FromUHugeint(uhugeint_t input); + //! Convert a hugeint object to a uuid style string static hugeint_t GenerateRandomUUID(RandomEngine &engine); static hugeint_t GenerateRandomUUID(); @@ -30171,7 +31311,7 @@ class Time { DUCKDB_API static dtime_t FromCString(const char *buf, idx_t len, bool strict = false); DUCKDB_API static bool TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict = false); DUCKDB_API static bool TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &result, - bool strict = false); + bool &has_offset, bool strict = false); // No hour limit DUCKDB_API static bool TryConvertInterval(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict = false); @@ -30708,7 +31848,7 @@ struct LocalFunctionData { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -30724,7 +31864,7 @@ struct GlobalFunctionData { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template @@ -30740,7 +31880,7 @@ struct PreparedBatchData { template TARGET &Cast() { - D_ASSERT(dynamic_cast(this)); + DynamicCastCheck(this); return reinterpret_cast(*this); } template diff --git a/mix.exs b/mix.exs index a30ac4b..bda3ded 100644 --- a/mix.exs +++ b/mix.exs @@ -1,8 +1,8 @@ defmodule Duckdbex.MixProject do use Mix.Project - @version "0.2.8" - @duckdb_version "0.10.0" + @version "0.2.9" + @duckdb_version "0.10.1" def project do [ diff --git a/test/nif/csv_test.exs b/test/nif/csv_test.exs index 09e520a..be997d1 100644 --- a/test/nif/csv_test.exs +++ b/test/nif/csv_test.exs @@ -10,11 +10,19 @@ defmodule Duckdbex.Nif.CSVTest do Map.put(ctx, :conn, conn) end - test "read csv", %{conn: conn} do + test "read csv auto infer options", %{conn: conn} do assert {:ok, res} = Duckdbex.NIF.query(conn, "SELECT * FROM 'test/support/data.csv';") assert [["1", "2", "3"], ["a", "b", "c"]] = Duckdbex.NIF.fetch_all(res) end + test "read csv using user defined options", %{conn: conn} do + assert {:ok, res} = Duckdbex.NIF.query(conn, "SELECT * FROM read_csv('test/support/data.csv', header = false);") + assert [["c1", "c2", "c3"], ["1", "2", "3"], ["a", "b", "c"]] = Duckdbex.NIF.fetch_all(res) + + assert {:ok, res} = Duckdbex.NIF.query(conn, "SELECT * FROM read_csv('test/support/data.csv', header = true);") + assert [["1", "2", "3"], ["a", "b", "c"]] = Duckdbex.NIF.fetch_all(res) + end + test "write csv", %{conn: conn} do assert {:ok, _} = NIF.query(conn, "CREATE TABLE tbl(the_date DATE, the_hugeint HUGEINT);") diff --git a/test/nif/types_test.exs b/test/nif/types_test.exs index df1c598..0ff66e9 100644 --- a/test/nif/types_test.exs +++ b/test/nif/types_test.exs @@ -394,8 +394,8 @@ defmodule Duckdbex.Nif.QueryTest do assert {:ok, r} = NIF.query(conn, "select map(['1', '5'], [1, 2]);") assert [[%{"1" => 1, "5" => 2}]] = NIF.fetch_all(r) - assert {:error, "Conversion Error: Could not convert string \"a\" to DECIMAL(12,2)"} = - NIF.query(conn, "select map([1, 2, 3], [1, 'a', 2.4::DECIMAL(3, 2)]);") + assert {:error, "Conversion Error:" <> _details} = + NIF.query(conn, "SELECT map([1, 2, 3], [1, 'a', 2.4::DECIMAL(3, 2)]);") assert {:ok, r} = NIF.query(conn, "select map([['a', 'b'], ['c', 'd']], [[1.1, 2.2], [3.3, 4.4]]);") @@ -413,7 +413,7 @@ defmodule Duckdbex.Nif.QueryTest do # assert {:error, "Invalid Input Error: Map keys have to be unique"} = # NIF.query(conn, "select map([1, 1, 1], ['a', 'b', 'c']);") - assert {:error, "Invalid Input Error: Map keys can not be NULL"} = + assert {:error, "Invalid Input Error:" <> _details} = NIF.query(conn, "select map([NULL, 5], ['a', 'e']);") assert {:ok, _} = NIF.query(conn, "CREATE TABLE map_table (map_col MAP(INT, DOUBLE));") diff --git a/test/support/data.csv b/test/support/data.csv index 21d40a0..6bda7ba 100644 --- a/test/support/data.csv +++ b/test/support/data.csv @@ -1,2 +1,3 @@ +c1,c2,c3 1,2,3 a,b,c